Stereoscopic Sketchpad: 3D Digital Ink

--Context-- This project looked at the development of a stereoscopic 3D environment in which a user is able to draw freely in all three dimensions. The main focus was on the storage and manipulation of the ‘digital ink’ with which the user draws. For a drawing and sketching package to be effective it must not only have an easy to use user interface, it must be able to handle all input data quickly and efficiently so that the user is able to focus fully on their drawing. --Background-- When it comes to sketching in three dimensions the majority of applications currently available rely on vector based drawing methods. This is primarily because the applications are designed to take a users two dimensional input and transform this into a three dimensional model. Having the sketch represented as vectors makes it simpler for the program to act upon its geometry and thus convert it to a model. There are a number of methods to achieve this aim including Gesture Based Modelling, Reconstruction and Blobby Inflation. Other vector based applications focus on the creation of curves allowing the user to draw within or on existing 3D models. They also allow the user to create wire frame type models. These stroke based applications bring the user closer to traditional sketching rather than the more structured modelling methods detailed. While at present the field is inundated with vector based applications mainly focused upon sketch-based modelling there are significantly less voxel based applications. The majority of these applications focus on the deformation and sculpting of voxmaps, almost the opposite of drawing and sketching, and the creation of three dimensional voxmaps from standard two dimensional pixmaps. How to actually sketch freely within a scene represented by a voxmap has rarely been explored. This comes as a surprise when so many of the standard 2D drawing programs in use today are pixel based. --Method-- As part of this project a simple three dimensional drawing program was designed and implemented using C and C++. This tool is known as Sketch3D and was created using a Model View Controller (MVC) architecture. Due to the modular nature of Sketch3Ds system architecture it is possible to plug a range of different data structures into the program to represent the ink in a variety of ways. A series of data structures have been implemented and were tested for efficiency. These structures were a simple list, a 3D array, and an octree. They have been tested for: the time it takes to insert or remove points from the structure; how easy it is to manipulate points once they are stored; and also how the number of points stored effects the draw and rendering times. One of the key issues brought up by this project was devising a means by which a user is able to draw in three dimensions while using only two dimensional input devices. The method settled upon and implemented involves using the mouse or a digital pen to sketch as one would in a standard 2D drawing package but also linking the up and down keyboard keys to the current depth. This allows the user to move in and out of the scene as they draw. A couple of user interface tools were also developed to assist the user. A 3D cursor was implemented and also a toggle, which when on, highlights all of the points intersecting the depth plane on which the cursor currently resides. These tools allow the user to see exactly where they are drawing in relation to previously drawn lines. --Results-- The tests conducted on the data structures clearly revealed that the octree was the most effective data structure. While not the most efficient in every area, it manages to avoid the major pitfalls of the other structures. The list was extremely quick to render and draw to the screen but suffered severely when it comes to finding and manipulating points already stored. In contrast the three dimensional array was able to erase or manipulate points effectively while the draw time rendered the structure effectively useless, taking huge amounts of time to draw each frame. The focus of this research was on how a 3D sketching package would go about storing and accessing the digital ink. This is just a basis for further research in this area and many issues touched upon in this paper will require a more in depth analysis. The primary area of this future research would be the creation of an effective user interface and the introduction of regular sketching package features such as the saving and loading of images

Ray Casting for Iso-surface in Volumetric Data

Volume data visualization is an active field of research and development. It can be applied in many areas such as medical, oil and gas exploration, etc... Although volume visualization is highly computational cost, there is a vision of real time volumetric visualization systems based on interactive ray tracing. Over the years, many rendering algorithms have been created and enhanced. The focus of this project is to develop a simple ray casting program for volumetric data. The program will be able to render specific volume data using a single processor in a reasonable amount of time. It is opento improve for implementation on multiprocessors. The thesis will compare some existing algorithms for ray casting in terms of image quality, computing time, complexity and so forth. The thesis includes a proposal of new multisampling algorithm, which significantly reduces rendering time while producing similar quality of image with existing algorithms

Algorithms and methods for discrete mesh repair

Computational analysis and design has become a fundamental part of product research, development, and manufacture in aerospace, automotive, and other industries. In general the success of the specific application depends heavily on the accuracy and consistency of the computational model used. The aim of this work is to reduce the time needed to prepare geometry for mesh generation. This will be accomplished by developing tools that semi-automatically repair discrete data. Providing a level of automation to the process of repairing large, complex problems in discrete data will significantly accelerate the grid generation process. The developed algorithms are meant to offer semi-automated solutions to complicated geometrical problems—specifically discrete mesh intersections and isolated boundaries. The intersection-repair strategy presented here focuses on repairing the intersection in-place as opposed to re-discretizing the intersecting geometries. Combining robust, efficient methods of detecting intersections and then repairing intersecting geometries in-place produces a significant improvement over techniques used in current literature. The result of this intersection process is a non-manifold, non-intersecting geometry that is free of duplicate and degenerate geometry. Results are presented showing the accuracy and consistency of the intersection repair tool. Isolated boundaries are a type of gap that current research does not address directly. They are defined by discrete boundary edges that are unable to be paired with nearby discrete boundary edges in order to fill the existing gap. In this research the method of repair seeks to fill the gap by extruding the isolated boundary along a defined vector so that it is topologically adjacent to a nearby surface. The outcome of the repair process is that the isolated boundaries no longer exist because the gap has been filled. Results are presented showing the precision of the edge projection and the advantage of edge splitting in the repair of isolated boundaries

A Sparse Voxel Octree-Based Framework for Computing Solar Radiation Using 3D City Models

abstract: An effective three-dimensional (3D) data representation is required to assess the spatial distribution of the photovoltaic potential over urban building roofs and facades using 3D city models. Voxels have long been used as a spatial data representation, but practical applications of the voxel representation have been limited compared with rasters in traditional two-dimensional (2D) geographic information systems (GIS). We propose to use sparse voxel octree (SVO) as a data representation to extend the GRASS GIS r.sun solar radiation model from 2D to 3D. The GRASS GIS r.sun model is nested in an SVO-based computing framework. The presented 3D solar radiation computing framework was applied to 3D building groups of different geometric complexities to demonstrate its efficiency and scalability. We presented a method to explicitly compute diffuse shading losses in r.sun, and found that diffuse shading losses can reduce up to 10% of the annual global radiation under clear sky conditions. Hence, diffuse shading losses are of significant importance especially in complex urban environments

Progressive refinement rendering of implicit surfaces

The visualisation of implicit surfaces can be an inefficient task when such surfaces are complex and highly detailed. Visualising a surface by first converting it to a polygon mesh may lead to an excessive polygon count. Visualising a surface by direct ray casting is often a slow procedure. In this paper we present a progressive refinement renderer for implicit surfaces that are Lipschitz continuous. The renderer first displays a low resolution estimate of what the final image is going to be and, as the computation progresses, increases the quality of this estimate at an interactive frame rate. This renderer provides a quick previewing facility that significantly reduces the design cycle of a new and complex implicit surface. The renderer is also capable of completing an image faster than a conventional implicit surface rendering algorithm based on ray casting

Ray Tracing Methods for Point Cloud Rendering

State of the art scanning and capturing devices are able to produce surface point cloud models of a wide range of real world objects. The visualization and rendering of enormous point clouds with millions or billions of points is demanding. VR- and AR-applications can utilize embedded real world objects in generating visually pleasing and immersive virtual worlds. In order to achieve convincing real life equivalents in VR, rendering techniques that can replicate realistic material and lighting effects are needed. This can be achieved by utilizing ray tracing methods to render the virtual world onto a monitor or a head-mounted display. Virtual reality applications need real-time stereoscopic rendering with high frame rates and resolution to produce a realistic and comfortable experience. This sets high demands on a point cloud ray tracing pipeline, which needs efficient intersection testing between rays and point cloud models. An easily intersectable global surface can be reconstructed from the point cloud model with, e.g., triangle mesh reconstruction. However, this can be computationally demanding and even wasteful if parts of the model are out of view or occluded. Direct point cloud ray tracing methods consider local features of the point cloud to generate intersectable surfaces only when needed. In this thesis, we survey and compare different methods for directly ray tracing point cloud models without global surface reconstruction. Methods are compared with asymptotic complexity analysis and it is concluded that direct ray tracing of point clouds can be computationally more efficient compared to global surface reconstruction

Moxel DAGs: Connecting Material Information to High Resolution Sparse Voxel DAGs

As time goes on, the demand for higher resolution and more visually rich images only increases. Unfortunately, creating these more realistic computer graphics is pushing our computational resources to their limits. In realistic rendering, one of the common ways 3D objects are represented is as volumetric elements called voxels. Traditionally, voxel data structures are known for their high memory requirements. One of the standard ways these requirements are minimized is by storing the voxels in a sparse voxel octree (SVO). Very recently, a method called High Resolution Sparse Voxel DAGs was presented that can store binary voxel data orders of magnitudes more efficiently than SVOs. This memory efficiency is achieved by converting the tree into a directed acyclic graph (DAG). The method was also shown to have competitive rendering performance to recent GPU ray tracers. Unfortunately, it does not support storing collections of rendering attributes, commonly called materials. These represent a given object\u27s reflectance properties, and are necessary for calculating its perceived color. We present a method for connecting material information to High Resolution Sparse Voxel DAGs for mid-level scenes, with multiple meshes, and several different materials. This is achieved using an extended Sparse Voxel DAG, called a Moxel DAG, and an external data structure for holding the material information, we call a Moxel Table. Our method is much more memory efficient than traditional SVOs, and only increases in efficiency in comparison when at higher resolutions. Because it stores the equivalent information as SVOs, it achieves the exact same visual quality at the same resolutions