Zhonghua Qu and Ovidiu Daescu December 24 2009 University of Texas at Dallas Introduction Assisting Visualization System Implementation Examples Conclusion Outline Introduction ID: 194055
Download Presentation The PPT/PDF document "Assisting Visualization System" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.
Slide1
Assisting Visualization System
Zhonghua
Qu
and
Ovidiu
Daescu
December
24, 2009
University of Texas at DallasSlide2
Introduction
Assisting Visualization System
Implementation Examples Conclusion
OutlineSlide3
Introduction
Visualization and Application
Implementing VisualizationIntegration ChallengesOur GoalAssisting Visualization System
The Implementation
Experiment Result Conclusion
OutlineSlide4
Computer Aided DesignIKEA Home Planner
Introduction:
Visualization and ApplicationsSlide5
Computer GamesFirst Person Shooting Games
Introduction:
Visualization and ApplicationsSlide6
Three
layers of visualization programs
Program ModelVisualization LayerGraphics EngineIntroduction: Implementing VisualizationSlide7
Program ModelLogic of Programs
For example, in car
simulation: when a driver turns the wheel, the orientation of the car should change correspondingly.Numerical Data
For example, the width and height of a
piece of furniture, or the coordinate of a vehicle. They are abstract and only different by the definition given.
Introduction:
Implementing VisualizationSlide8
Visualization and Graphics Engine3D Graphics Rendering
Includes the detailed implementation
of how the object inside the program model should be rendered on the screen. For example, a chair
object
is rendered based on its size, type, material
etc.
Graphics Engine
Implementation of
rendering
algorithms.
Provides
more abstract control over the object rendered.
Introduction:
Implementing VisualizationSlide9
Steep Learning Curve To use the graphics engine for visualization requires significant 3D graphics knowledge including matrix
transformation,
lighting etc.
Graphics Engine
Introduction:
Concerns about Visualization Layer
Visualization Code
Matrix Transformation
Lighting Model
Texture Format
….
….Slide10
Not Flexible Once the visualization layer is
built
the visualization schema cannot be changed without modifying the code. Introduction:
Concerns about Visualization Layer
Program
Visualization Layer
Visualization LayerSlide11
Not reusable
Changing the underlying program
forces changes in the definition of the visualization. This implies rewriting most of the code.Introduction:
Concerns about Visualization Layer
Program
Program
Visualization LayerSlide12
Provide a visualization system
Doesn’t require
Graphics KnowledgeFlexible to change the visualization schemaReusable between applications
Introduction: Our GoalSlide13
Introduction
Assisting
Visualization SystemOverviewVisual ComponentBinding with Program Implementation
Examples
Conclusion
OutlineSlide14
Achieve Visualization
without
actually programming graphics Flexible and easy to adjust the visualization schema
Highly
reusable visualization layer
Assisting Visualization System: OverviewSlide15
Achieve Visualization
Without
ProgrammingUse an approach called BindingTreat visualizations
as
components No visualization
Code
in program
Bind
visualization at runtime
Binding Defined Through
XML
Assisting Visualization System: OverviewSlide16
Achieve Visualization
without
actually programming graphics Flexible
and easy to adjust the visualization schema
Highly reusable visualization layer
Assisting Visualization System: OverviewSlide17
No
hard coded
visualization layerDefine Visualization Through XMLNo source code modification required
Doesn’t need
recompilation Easy to check the visualization
definition
Assisting Visualization System: OverviewSlide18
Achieve Visualization without actually programming graphics
Flexible and easy to adjust the visualization schema
Highly reusable visualization layerAssisting Visualization System: OverviewSlide19
Reuse
visualization
across programsReusable Visual ComponentIntegrated through XML
bindingNo data structure
dependency
Reusable through
changing
the
binding
Assisting Visualization System: OverviewSlide20
Achieve Visualization without actually programming graphics
Flexible and easy to adjust the visualization schema
Highly reusable visualization codeAssisting Visualization System: OverviewSlide21
Aggregation of Visualization Code
Interacts with
Graphics EngineNot tied to any application
Reusable
across applicationsReady to use component developed by third
party
Assisting Visualization System:
Visual ComponentSlide22
What is the basis for binding?
Object Oriented Programming Language
One visual component per class Each class can bind to one visual component. During the execution of the program
, this class will be visualized by the visual component.
One visualized entity
per object
instance
Whenever a new instance of the class is created, an instance of the visual component which is tied to the program instance is created and rendered on the screen.
Assisting Visualization System: Binding with ProgramSlide23
Introduction
Assisting Visualization System
ImplementationOverviewProgram LoaderCode Execution Monitor
Rendering System
Binding Definition Format Examples
Conclusion
OutlineSlide24
Implementation Language: Java
Cross Platform
Applets run in browser on InternetLow development cost
Third party graphics engine:
Jmonkey EngineWritten in
Java
Using
OpenGL
for rendering
Open
source
project
Used in many
commercial
software
Implementation
: OverviewSlide25
Major ComponentsProgram Loader
Loads and modifies the target java program to integrate it
with the visualization framework. Code Execution Monitor
Monitors
the execution of
the target
program and
realizes
the visualization
binding
.
Rendering System
Manages
the life cycle of
visual
component
instances that
tie
with underlying target program.
Renders
the visual components using
Jmonkey
Graphics Engine.
Implementation: OverviewSlide26
Customized Java Class
LoaderLoads class binary from file into memory for Java virtual machineCode injection
at load timeInject binary code at runtime before the class is used by Java virtual machineInteract with Code
Execution
Monitor
Register target class information and call handler function inside execution monitor
Implementation:
Program LoaderSlide27
Monitors the target program execution
New
instance creation Call Render System to create visual component instance and tie to the underlying objectObject garbage
collectionRemove the object entry from the monitor
Object
value
changed
Update the binding property in its tied visual component correspondingly
Implementation:
Code Execution MonitorSlide28
Visual Component Management
Load
visual component Search for visual component java class file for the visual componentCreate, remove visual component Manage the visual component based on outside system call
Render
visual components Use Graphics Engine to finally render the visual component
Implementation:
Rendering SystemSlide29
Jmonkey
Graphics Engine
FunctionsCreate User Interface Create visualization window in which all visual components are renderedModel Loading Load 3D models from files on disk and store
in memory as an object
Scene graph Management Object oriented way of accessing the 3D objects in the rendered environment
Implementation:
Rendering SystemSlide30
Graphics Engine: Jmonkey
Engine
Rendering OutputImplementation: OverviewSlide31
Graphics Engine: Jmonkey
EngineRendering OutputImplementation: OverviewSlide32
XML Format
Simplicity,
easily accessible to developersOpen format, many tools availableBinding XML Schema
Define the format of binding xml
Document for people writing the binding XMLAutomated parsing inside visualization system
Implementation:
Binding Definition FileSlide33
XML
Parsing
Apache XMLBeans library Open source XML parsing library under Apache foundation.Automatic java parsing code generation base on Schema File Generate source code for parser based on the schema file. V
isit
the content of the XML file using an object oriented approach
.
Implementation:
Binding Definition FileSlide34
Introduction
Binding Approach
Assisting Visualization System Implementation
ExamplesQuickSort
Growing Tree
Conclusion
OutlineSlide35
Visualization of QuickSort
on 80 elements
Experimental Results: QuickSortSlide36
Visual Component Binding with Java Program
Java Class:
SortElementVisual Component: BarVOBindings1
ClassBind
3 PropertyBind
Examples:
QuickSortSlide37
Visual Component Binding with Java Program
ClassBind
– Bind SortElement with BarVOBinding XML<
ClassBind
> <TargetClass name=“SortElement”> <Constructor signature="()V" /> </TargetClass
>
<
VisualObject
name
=“
BarVO
”
>
<Parameter key="
scaleX
" value="10" />
<Parameter key="
scaleZ
" value="50" />
</
VisualObject></
ClassBind
>
Examples:
QuickSortSlide38
Visual Component Binding with Java Program
PropertyBind
– SortElement.value to BarVO.scaleYBinding XML<
PropertyMap
className="SortElement" toName="scaleY"> <Field
name="
value*500
" />
</
PropertyMap
>
Examples:
QuickSortSlide39
Visual Component Binding with Java Program
PropertyBind
– SortElement.index to BarVO.xBinding XML<PropertyMap
className
="SortElement" toName="x”> <InterpolateParam key="adaptFactor
" value="0.0" />
<
InterpolateParam
key="
estimateInterval
" value="0.7" />
<
Field
name="
(float)index*20.0
" />
</
PropertyMap
>
Examples:
QuickSortSlide40
Visual Component Binding with Java Program
PropertyBind
– to BarVO.zBinding XML<PropertyMap className="demo.sort.SortElement" toName
=
"z“> <InterpolateParam
key="
adaptFactor
" value="0.0" />
<
InterpolateParam
key="
estimateInterval
" value="0.1" />
<
Code
outVar
="offset">
float offset=0.0f;
if(pivot) offset=100f;
else offset=0f;
</Code>
</
PropertyMap
>
Examples: QuickSortSlide41
Visual Component Binding with Java Program
Resulting Visualization:
Examples: QuickSortSlide42
Changing the Visualization for
QuickSort
Use color instead of height to represent value of
SortElementBinding XML
Before
<
PropertyMap
className
="
demo.sort.SortElement
"
toName
="
scaleY
">
<Field name="value*500" />
</
PropertyMap
>
After
<
PropertyMap
className="demo.sort.SortElement" toName="colorRed"> <Field name="value" />
</PropertyMap>
Examples: QuickSortSlide43
Changing the Visualization for
QuickSort
Resulting Visualization:Examples: QuickSortSlide44
Changing the Visualization for
QuickSort
Display index of SortElement on a curve
Binding XML
Before<PropertyMap className
="
demo.sort.SortElement
"
toName
="
x
“>
<
Field
name="(float)index*20.0" />
</
PropertyMap
>
After
<
PropertyMap
className
="
demo.sort.SortElement
" toName="rotateW“> <Field name="Math.cos(-((float)index/(float)maxIndex
*Math.PI- Math.PI/2f)*0.5f)" /></PropertyMap>
<PropertyMap className="demo.sort.SortElement" toName="
rotateY">
<Field name="Math.sin(-((float)index/(float)maxIndex*
Math.PI- Math.PI/2f)*0.5f)" />
</PropertyMap>Examples: QuickSortSlide45
Changing the Visualization for
QuickSort
Resulting Visualization:Examples: QuickSortSlide46
Visualization of a growing TreeGrowing Tree with branch factor 3
Examples:
Growing TreeSlide47
Visualizatoin for trajectory simulation
Simulation
of the movment of 80 elements with gravity influence on each otherExamples: Orbiting MassSlide48
Introduction
Binding
ApproachAssisting Visualization System
Implementation
Examples
Conclusion
OutlineSlide49
Introduced visualization through binding approach.Implemented Assisting Visualization System
Decoupled from underlying program
Flexible to change visualization schemaReusable visual componentCreated a prototype system that can be adopted in languages other than Java.Conclusion: