This document presents an approach for interactively rendering complex 3D treemaps with over 600,000 items. It generates geometry for treemap items using a GPU-based approach, representing each item as an attributed point cloud. This enables efficient rendering while using less memory than CPU-based approaches. The method culls invisible geometry, applies thematic mappings, and uses post-processing for styling. It outperforms existing techniques in rendering speed and memory usage. Future work could improve readability, apply new visualization techniques, and generalize the approach.
UGC NET Paper 1 Mathematical Reasoning & Aptitude.pdf
Rendering of Complex 3D Treemaps (GRAPP 2013)
1. Interactive Rendering
of Complex 3D-Treemaps
Matthias Trapp, Sebastian Schmechel, Jürgen Döllner
Hasso-Plattner-Institute, University of Potsdam, Germany
2. Agenda
I. Motivation
II. Conceptual Overview
III. Implementation Details
IV. Results & Discussion
V. Future Work & Conclusions
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 2
5. Related Work
2D Treemaps [Shneiderman ’92, Bederson ’02]:
Common technique for space restricted hierarchy
visualization
Various layouting algorithms available
3D Treemap / StepTree [Bladh, 2004]
Can be used to map additional attributes of the data items
Significantly better performance in interpreting the
hierarchical structure
Preserve performance in interpretational/navigational
tasks
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 5
6. Image-Synthesis of a 3D Treemap
Computation of 2D Treemap Layout
Mapping of Thematic Data to Treemap Items
Generation of 3D Rendering Primitives
Rendering/Rasterization of 3D Rendering Primitives
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 6
7. 3D Treemap >600k Items
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 7
8. 3D Treemap Item
Additional dimension =
additional complexity
Observation: 3D treemap = 2.5D virtual
environment
3-5 times more geometry required than 2D case
Attributes for thematic mappings vary per item
Number of items determines update performance
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 8
9. Challenges for Complex 3D Treemaps
3D Treemap ~ geometrical complex
representation:
High memory footprint in VRAM
High run-time complexity for item updates
High run-time complexity for layout
Efficient rendering depends on/is determined by:
Rendering run-time complexity
Update run-time complexity
Client/Server memory consumption/space
complexity
Goal: Reduction ofComplex 3D Treemaps :: Matthias Trapp complexity
02/22/2013 Rendering of space and time 9
11. Treemap Item :: Parameterization
Goals:
1. Provide a small-as-possible memory footprint on client
2. Support fast client-server updates
Layout-dependent attributes:
2D item position & size (X, Y, W, H)
Mapping-dependent attributes:
Item color & item identity (R, G, B, ID)
Item depth & Z-position (D, Z)
Hierarchy Level (L)
Binary flags, e.g., isLeaf, isVisible, isSelected,… (F)
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 11
12. Treemap Item :: Buffer Mapping
Assumption:
mapping and layout are often modified separately
Two separate buffers: layout and mapping buffer
Can be updated separately and saves bandwidth
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 12
13. Approach :: Overview
Three-stage deferred rendering process:
1. Generate and render attributed point cloud
2. Generate primitives & rasterize to G-Buffer (1 pass)
3. Apply post-processing techniques (1 pass)
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 13
14. Approach :: Attributed Point Cloud
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 14
15. Approach :: Generated Primitives
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 15
16. Approach :: Thematic Mapping
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 16
17. Approach :: Post Processing
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 17
18. Approach :: Summary
Fully GPU accelerated shape generation
Render attributed point cloud and generate triangles
Enables a compact representation of treemaps
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 18
22. Culling Strategies
Backface Culling:
Goal: omit rasterization of back-facing primitives
Performed using fixed-function pipeline feature
Overhead if performed in geometry shader
View-frustum Culling:
Goal: omit shape generation for items outside the frustum
Performed per-item in vertex shader
Size Culling:
Goal: omit rasterization of small treemap items
Performed per-item in vertex shader
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 22
23. Size–Culling using a Screen-Space Metric
a max p0 x ,, p7 x min p0 x ,, p7 x b max p0 y ,, p7 y min p0 y ,, p7 y
true a b
passSizeCulling
false otherwise
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 23
24. Culling Implementation
bool passCulling(const in mat4 mvp, const in vec4 vertex, const in vec4 dimensions,
const in bool applyViewFrustumCulling, const in bool applySizeCulling)
{ float cPMaxX=-10000.0;float cPMinX=10000.0;float cPMaxY=-10000.0;float cPMinY=10000.0;
bool passCulling = true;
if(useViewFrustumCulling)
{ // 1. Do conservative culling and test only center of item
vec4 V = mvp * vertex;
passCulling=((-V.w<V.x)&&(V.x<V.w))&&((-V.w<V.y)&&(V.y<V.w))&&((-V.w<V.z)&&(V.z<V.w));
if(!passCulling)
{ // 2. Perform precise culling if item center is not in frustum
vec4 AABB[8];
for (int i = 0; i < 8; i++){
AABB[i] = mvp * (vertex + VERTEX[i] * dimensions);
vec4 p = AABB[i] / AABB[i].w;
p.xy = (p.xy + 1.0) * (viewport.zw * 0.5) + viewport.xy;
cPMaxX = max(cPMaxX, p.x); cPMinX = min(cPMinX, p.x);
cPMaxY = max(cPMaxY, p.y); cPMinY = min(cPMinY, p.y);
} //endfor
// 2. Perform precise culling if item center is not in frustum
int bounds[6] = int[6](0,0,0,0,0,0);
for(int i = 0; i < 8; i++){
if(AABB[i].x>AABB[i].w) bounds[0]++; if(AABB[i].x<-AABB[i].w) bounds[1]++;
if(AABB[i].y>AABB[i].w) bounds[2]++; if(AABB[i].y<-AABB[i].w) bounds[3]++;
if(AABB[i].z>AABB[i].w) bounds[4]++; if(AABB[i].z<-AABB[i].w) bounds[5]++;
}//endfor
for(int i = 0; i < 6; i++) if(bounds[i]==8) passCulling = false;
}//endif }//endif
// 3. Apply size culling if enable to every visible item
if(passCulling && applyViewFrustumCulling && useSizeCulling)
passCulling = ((abs(cPMaxX)-abs(cPMinX))*(abs(cPMaxY)-abs(cPMinY)))
> float(pixelSizeThreshold);
return passCulling;
}
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 24
25. Deferred Stylization :: Overview
Performed in post-processing: low per-fragment cost
Can be customized to user demands/rendering
speed
Rendering overhead: ca. 1-3 ms @ 720p
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 25
26. Deferred Stylization :: Variances
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 26
28. Comparison of Approaches
Difference: Geometry generation on CPU vs. GPU
Utilized stage/approach has impact on:
Bandwidth required (CPU GPU)
Main (CPU) and video (GPU) memory footprints
Number of draw calls issued
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 28
29. Existing Approaches
Vertex Buffer Objects (VBO):
Generate geometry for each treemap item
client-side (CPU) and push to server (GPU)
Index variant has low memory footprint and
leverage post-transform cache (~32 vertices)
CPU bound for frequent treemap updates
Geometry Instancing (Pseudo, UBO, TBO)
Encoding of per-instance-data (PID) is bottleneck:
Pseudo-Instancing: encode PID in shader constant
registers
Uniform-Buffer Instancing: encode PID to L1-Cache
(~64K)
Texture-Buffer Instancing:3Dencode PID to texture
02/22/2013 Rendering of Complex Treemaps :: Matthias Trapp 29
31. Memory Footprint :: Metric
#Bytes for n treemap items with a attributes
compression ratios for VRAM consumption:
1:2.5 over indexed vertex representations
1:3.75 over non-index vertex representations
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 31
33. Discussion
Outperforms all existing rendering techniques:
Pseudo & UBO Instancing are CPU bound
TBO instancing is bound by L2-Cache performance
VBOs probably transform bound
Indexed VBO leverage post-transform cache
Generation and instancing have similar memory footprint
All approaches are not fill-limited
Theoretical limits of the presented approach:
~2.5 million 3D treemap items at ~20 frames-per-second
Equals 1 pixel-per-item at full HD resolution (1920x1080)
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 33
35. Future Work :: Reduce Overdraw
high overdraw low overdraw
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 35
36. Future Work :: Reduce Overdraw
Independent Representation Interdependent Representation
A B
L2
Item Origin
L1
L0
Unnecessary Item Overdraw L ~ Hierachy Level of Item
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 36
37. Future Work :: Improve Readability
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 37
38. Future Work :: Concept Transfer
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 38
39. Future Work :: Summary
Foundation for advanced visualization techniques:
Animated transition between 3D treemap states
Application of interactive focus+context lenses
Multi-perspective views of 3D treemaps
Generalize approach for other treemap types:
3D Voronoi treemaps
Classical 2D (Voronoi) treemaps
02/22/2013 Rendering of Complex 3D Treemaps :: Matthias Trapp 39
40. Conclusions
Rendering technique for complex 3D treemaps
Outperforms existing approaches w.r.t.:
Rendering speed
Memory requirements (client & server)
Building block for GPU framework for 3D treemaps
Stylization possibilities are limited (e.g.
,transparency)
Potentials for future work
02/22/2013 Interactive Rendering of Complex 3D Treemaps :: Matthias Trapp 40
41. Questions & Comments
Contact:
www.4dndvis.de
Matthias Trapp
matthias.trapp@hpi.uni-potsdam.de
Sebastian Schmechel
sebastian.schmechel@hpi.uni-potsdam.de
Jürgen Döllner
juergen.doellner@hpi.uni-potsdam.de
Publications:
http://www.hpi.uni-potsdam.de/doellner/4dndvis/publikationen.html
This work was funded by the Federal Ministry of Education and Research
(BMBF), Germany within the InnoProfile Transfer research group "4DnD-Vis".
07/23/2012 Rendering of Complex 3D Treemaps :: Matthias Trapp 41
Notas do Editor
Domain: Software Visualization- Different metricaremappedtothetreemaplayout, item sizeandcolor
Squarified, Slice & Dice, Strip, andVoronio
Visualizationof massive datausing 3D treemapsFullyhardwareaccleratedlayoutingandrenderinginteractivefiltering,Animatedtransitions,Automatic generalizationoftreemaps
As mostofyouknow, theapplicationofcullingstrategiesampliedtheperformanceof an redneringtechnique
References
Despite intermediate mode:
CPU: Single threadedForothermachinespleaseread-up in thepaperThe rendering technique was tested using four datasets of different geometric complexity: 35.089,96.658, 365.645, and 614.929 items. The performancetests are conducted on three different test platformswith different GPU generations: (1) NVIDIAGeForce GTX 460 GPU with 1024MB video memoryon an Intel Xeon W3530 CPU with 2,8GHz and6GB of main memory; (2) NVIDIA GeForce GTX480 with 1.5GB video memory on an Intel XeonW3520 2.67GHz and 24GB of main memory; and (3)NVIDIA GeForce GTX 560 Ti with 2GB video memoryon an Intel Xeon W3550 3.07GHz and 6GB ofmainmemory.The test application runs in windowed mode athigh-definition resolution of 1280720 pixels. Thecomplete scene is visible in the view frustum, thusview-frustum culling is not applied. Further backfaceculling is activated and size culling is deactivated.For each rendering technique, a total of 5000consecutive frames are rendered and the respectiverun-time performance in milliseconds is tracked. Afterperformance tracking, all records are averaged. Todetermine to update performance, the time requiredbetween committing a new data set to the renderingtechniques and the next frames rendered is measuredin milliseconds. Styling is turned off to measure
Logarithmicscale
- Transfer conceptsofcartographicgeneralizationto 3D Treemaps