Refine
Document Type
- Bachelor Thesis (17)
- Master's Thesis (2)
Keywords
- Computervisualistik (4)
- Computergrafik (3)
- Line Space (3)
- Datenstruktur (2)
- Global Illumination (2)
- Linespace (2)
- Path Tracing (2)
- Raytracing (2)
- Realistische Computergrafik (2)
- 3D-Scan (1)
Bildsynthese durch Raytracing gewinnt durch Hardware-Unterstützung in Verbraucher-Grafikkarten eine immer größer werdende Relevanz. Der Linespace dient dabei als eine neue, vielversprechende Beschleunigungsstruktur. Durch seine richtungsbasierte Natur ist es sinnvoll, ihn in andere Datenstrukturen zu integrieren. Bisher wurde er in ein Uniform-Grid integriert. Problematisch werden einheitlich große Voxel allerdings bei Szenen mit variierbarem Detailgrad. Diese Arbeit führt den adaptiven Linespace ein, eine Kombination aus Octree und Linespace. Die Struktur wird hinsichtlich ihrer Beschleunigungsfähigkeit untersucht und mit dem bisherigen Grid-Ansatz verglichen. Es wird gezeigt, dass der adaptive Linespace für hohe Grid-Auflösungen besser skaliert, durch eine ineffiziente GPU-Nutzung allerdings keine optimalen Werte erzielt.
This thesis tests several methods and measures in pathtracing for selecting either the Line Space or the Bounding Volume Hierarchy data structure to make use of the advantages of both. The structures are defined locally around each object and each Line Space shaft contains one candidate ID each. All implementation is done as a C++ and OpenGL framework with compute shaders handling the pathtracing and Line Space generation. The measures include the probability distribution, the effect dependency, as well as a distance threshold and are tested against several different scenes. In most situations, the results show a noticeable increase in performance, partly only with minor visual differences, with the probability measure producing the highest quality images for a given performance. The fundamental problems of the Line Space concering the high memory consumption and a long generation time compared to the BVH still persist, despite the object local structure, a minimal amount of data per shaft and the compute shader implementation.
This thesis presents an approach to optimizing the computation of soft shadows from area lights. The light source is sampled uniformly by traversing shadow rays as packets through an N-tree. This data structure stores an additional line space for every node. A line space stores precomputed information about geometry inside of shafts from one to another side of the node. This visibility information is used to terminate a ray. Additionally the graphics processing unit (short GPU) is used to speed up the computations through parallelism. The scene is rendered with OpenGL and the shadow value is computed on the GPU for each pixel. Evaluating the implementation shows a performance gain of 86% by comparison to the CPU, if using the GPU implementation. Using the line space instead of triangle intersections also increases the performance. The implementation provides good scaling with an increasing amount of triangles and has no visual disadvantages for many rays.
Deformable Snow Rendering
(2019)
Accurate snow simulation is key to capture snow's iconic visuals. Intricate
methods exist that attempt to grasp snow behaviour in a holistic manner. Computational complexity prevents them from reaching real-time performance. This thesis presents three techniques making use of the GPU that focus on the deformation of a snow surface in real-time. The approaches are examined by their ability to scale with an increasing number of deformation actors and their visual portrayal of snow deformation. The findings indicate that the approaches maintain real-time performance well into several hundred individual deformation actors. However, these approaches each have their individual restrictions handicapping the visual results. An experimental approach is to combine the techniques at reduced deformation actor count to benefit from the detailed, merged deformation pattern.
The development of a game engine is considered a non-trivial problem. [3] The architecture of such simulation software must be able to manage large amounts of simulation objects in real-time while dealing with “crosscutting concerns” [3,p. 36] between subsystems. The use of object oriented paradigms to model simulation objects in class hierarchies has been reported as incompatible with constantly changing demands during game development [2, p. 9], resulting in anti-patterns and eventual, messy refactoring.[13]
Alternative architectures using data oriented paradigms revolving around object composition and aggregation have been proposed as a result. [13, 9, 1, 11]
This thesis describes the development of such an architecture with the explicit goals to be simple, inherently compatible with data oriented design, and to make reasoning about performance characteristics possible. Concepts are formally defined to help analyze the problem and evaluate results. A functional implementation of the architecture is presented together with use cases common to simulation software.
This thesis explores different approaches for the acceleration of raytracing calculations on the graphics processing unit (GPU). For that a voxel grid is used and extended by the linespace data structure. The linespace consists of direction based shafts and stores the objects located in those shafts in a candidate list. Different methods for the sorting and traversal of the linespace are presented and evaluated. The shown methods cannot provide a speed up of the frame rate without resulting in a loss of image quality.
A special challenge of the basic musical education of children is to give them an understanding of reading and writing musical scores. During the training of young choristers it is furthermore important to educate them in directly transforming the written scores into sounds.
Therefore it is an interesting idea to play the sounds to the children via piano or keyboard and simultaneously present them on a screen in musical notation.
The aim of this bachelor thesis is the implementation of such a system that allows to enter scores using a MIDI-compatible keyboard and then depicting these as musical notation. The prototype of the application operates in three steps. It receives the musical scores via keyboard in form of MIDIdatasets. These MIDI-information are converted to the MusicXML-format. Based on this MusicXML-notation the software finally generates and displays the visual output.
This thesis deals with the development of an interactive Android card game. As an example, the Hebrew game Yaniv was implemented. Focus is the elaboration of required background components and the corresponding implementation in that application. Required game processes will be screened and a possible solution will be identified.
Ray Tracing enables a close to reality rendering implementation of a modelled scene. Because of its functioning, it is able to display optical phenomena and complex lighting. Though, numerous computations per pixel have to be done. In practice implementations can not achieve computer graphics" aim of real-time rendering close to 60 frames per second. Current Graphics Processing Units (GPU) allows high execution parallelism of general-purpose computations. By using the graphics-API OpenGL this parallelism can be achieved and it is possible to design and realize a Ray-Tracer, which operates entirely on the GPU. The developed approach will be extended by an Uniform Grid - a Ray-Tracing acceleration structure. Hence, a speed-up is expected.
This thesis` purpose is the implementation of Ray-Tracer, which operates completely on the GPU, and its expansion by integrating an Uniform Grid. Afterwards, the evaluation of maximum achievable performance takes place. Possible problems regarding GPU-programming will be identified and analysed.
This thesis presents the use of a local linespace data structure, which is designed and implemented on the basis of an existing GPU-based raytra- cer with a global linespace data structure. For each scene object, an N-tree is generated whose nodes each have a linespace. This saves informations about existing geometry in its shafts. A shaft represents a volume between two faces on the outside of the node. This allows a faster skipping of em- pty spaces during raytracing. Identical objects can access already calcula- ted linespaces, which can reduce the memory requirement by up to 94.13% and the initialization time of the datastructure by up to 97.15%. Due to the local access possibilities dynamic scenes can be visualized. An increase in quality can also be observed.