Advanced Rendering Toolkit
Project Ideas

simple	...	Praktikum 1
medium / advanced	...	Praktikum 2 / Wahlfachpraktikum
master's thesis	...	Diplomarbeit

Texturing for raytracing

(a) Solid texturing library [simple]

ART has a first implementation of wood and marble texture functions based on Perlin's noise function. Modify these functions and/or find optimal parameter values for realistic looking wood and marble textures. Build a small library of different woods and marbles. Modify current texturing functions or implement new texturing functions for creating dirt, rust, stains, aso. Build a small library.

(b) Texture mapping functions [medium]

Implement a variety of projection functions and parametrizations for all the primitive objects in the ART system. Add flags to choose texture mappings that preserve angles, areas, aso.

(c) Texture synthesis on demand [advanced]

Implement a version of the following algorithm that calculates pixel values on demand. Jeremy S. De Bonet: Multiresolution Sampling Procedure for Analysis and Synthesis of Texture Images, Computer Graphics Proceedings SIGGRAPH 97, pp. 361--368

Raytracing sweeps

(a) Translational and conical sweeps [simple, but a bit of work]

Implement quadric 2D primitives and intersection routines of a 2D-Ray with these primitives. Use ArnRayCaster as a state-object for these intersection routines as well, and add methods to do these intersections to ArnRayCaster. Add 2D-raycasting routines to the CSG nodes. Implement objects ArnTransSweep and ArnConicalSweep that sweep these 2-D objects from z=0 to z=1.

(b) Rotational sweeps [medium, depends on (a)]

Implement intersection routines of the 2D-primitives with a hyperbola. For quadrics this gives an order-4 equation which can be solved using Math/Roots.h

(c) Advanced rotational sweeps [medium, depends on (b)]

Add 2-D piecewise cubic curve primitive and implement intersection of the 2D-Ray and a Hyperbola. With the Hyperbola you get an order-6 equation that has to be solved. For this a Sturm sequence based solver from Graphics Gems has been put into Math/ArPolynomial.h (WARNING: this module is untested!)

New primitive shapes

(a) Quadric objects [simple]

Add a generalized quadric object with a coefficient table. Bound the object using local bounding planes compareable to the cylinder and cube (let the user specify the bounding box i.e. the extension of the object in each coordinate direction, when defining the object).

(b) Quartic objects [simple]

Add a generalized quartic object with a coefficient table. Bound the object using local bounding planes compareable to the cylinder and cube (let the user specify the bounding box, i.e. the extension of the object in each coordinate direction, when defining the object).

(c) Polynomial objects [medium]

Add a generalized polynomial object with a coefficient table. For this a Sturm sequence based solver from Graphics Gems has been put into Math/ArPolynomial.h (WARNING: this module is untested!) Bound the object using local bounding planes compareable to the cylinder and cube (let the user specify the bounding box i.e. the extension of the object in each coordinate direction, when defining the object).

(d) Double/single plane convex objects [simple]

Add convex polygonal objects bounded by a set of single and double planes. This will provide the implementation for fast platonics and brilliants. Of course this includes also defining all platonics.

(e) Heightfield objects [simple]

Add heightfield objects with specialized fast intersection routines.

Parametrised objects and textures for raytracing

(a) References and named objects [medium]

Implement a way to read and write non-DAG graphs by using references, i.e. pointers to other objects that are created in a second pass after the DAG skeleton has been read in. Use names to make these references convenient to use. Note that the 'combineAttributes' method should not carry attributes across these references. Implement these references as a special node called 'ArnReference'.

(b) Parametrised objects [medium]

Implement parameters using a hashtable (ArnEnvironment) that is passed along with the traversal operation of the tree. Values of variables are stored and retrieved from this environment. (For this purpose, the hashtable in the Basics library already implements a stack functionality for adding and deleting key-value pairs.) Add nodes to the Value library to access and operate on these variables, and general nodes to the Node Library to set these variables (ArnSetParameter), and decide on these variables (ArnSelectionNode).

(c) Raytracing of parametrised objects [simple, depends on (a) and (b)]

Implement a copy method that creates a flattened version of the directed cyclic graph that is possible with the two previous projects.

(d) Dynamic raytracing of DCG [advanced, depends on (a) and (b)]

Use the ideas presented in the dissertation of Chris Traxler to implement a dynamic method of raytracing DCGs.

(e) Parametrised textures [medium, depends on (a) and (b)]

In a preprocessing step, calculate for each primitive what parameters are needed in each of its textures. Put the information that has been found into an additional (fourth) subnode in ArnCombined and into ArnTraversal, so that the Hit-creation routines can easily put the necessary variables into the environment that is created for each hit.

(f) Optimizing parametrised objects [simple, depends on (a) and (b)]

Implement an optimize for expressions that creates a p-code type object that evaluates all its variables at once and then calculates the value of the expression using a p-code.

Fast raytracing

(a) A grid-tracer [simple-medium]

Use the ideas present in ArnOctree (clip to BBox, aso.) to implement a grid-tracing node ArnGrid.

(b) Hierarchical grid-tracer [simple, dependes on a]

Extend the grid-tracer to subdivide voxels that are very crowded.

(c) A BSP-tracer [medium]

Implement a BSP node that subdivides space along a general plane and use the ideas present in ArnBBox.h/ArnCSGorBBox/optimizeBBoxes for subdividing space.

(d) An octree tracer [medium]

Implement fast raytracing using octrees. Add subdivision on demand, optimize the performance by tuning subdivision parameters (counting objects, object intersections).

(e) Optimizing polygon intersection routines [simple]

At the moment polygons are subdivided into triangles, and each triangle is checked against a possible intersection. Improve the memory requirements by implementing a special polygon intersection routine, and optimize the speed of this routine.

(f) Implement the permute-scale-shift transformation [simple]

In architectural scenes a lot of objects are axis-aligned. In order to speed up the transformation into the local coordinate system, it is possible to analyse the transformation, find out about this fact, and create a specialised transformation that contains a permutation (there are 6 possible permutations of the three coordinates) a scaling information and a shift information. Implement this special transformation called 'ArnPermuteScaleShift3D', and check the speedup.

(g) Arbitrarily oriented double bounding planes [medium]

Implement a double-plane bounding volume for a tighter fit around polygonal meshes. Investigate heuristics to build hierarchies of this type of bounding volumes.

(h) Viewing frustum culling / image space subdivision [medium]

Implement a 'clipToPolyhedron' routine that returns a clipped version of the object that is clipped to the supplied convex polyhedron. Use this to speed up the intersection of primary rays, by creating a grid in the image plane and creating a clipped version of the scene as seen through each of the grid-elements (clip to frustum).

Colour systems

(a) HSL and colour naming system [simple]

Add a module 'HLS' to the Graphics Library that makes it possible to specify colours using the HSL colour system. Add a module 'CNS' to the graphics Library that makes it possible to specify colours using the colour naming system. Add a user-friendly interface for these to modules so that they can be easily used in an '.arm' file.

(b) Gamut mapping [medium]

Currently ART already implement a primitive gamut mapping function. Implement a few more methods for gamut mapping.

(c) CMYK and correct printing [advanced, scaleable to thesis]

Implement the CMYK colour space and conversions from and to it. Devise a procedure to calibrate colour printers using colour measurement tools (available at the Institute of Computergraphics).

Improved camera implementation

(a) Standard Cameras [simple]

Investigate camera definition of POV, Open GL, VRML, RenderMan and other systems. Create a camera system that provides all the functionality of these systems, with a possibiltiy to read camera definitions from all these other systems.

(b) Extended Cameras [medium]

Implement Helwig Löffelmann's extended specification for cameras with arbitrarily parametrized and twisted projection planes.

Software z-buffer

(a) Z-buffer for polygons [medium]

Implement a standard software Z-buffer for ART which works for triangles, quadrangles, polygons and meshes.

(b) Adaptive meshing of CSG primitive objects [medium, depends on (a)]

Extend the software Z-buffer, to adaptively mesh CSG primitive objects, according to their size and transformation into screen space.

(c) Z-buffer for CSG [advanced, depends on (a) and (b)]

Extend the Z-buffer to handle CSG combination operators.

Open-GL interface

(a) Open GL for polygons [medium]

Add a library for rendering triangles, quadrangles, polygons and meshes that are defined in ART using Open GL.

(b) Adaptive meshing of CSG primitive objects [medium, depends on (a)]

Extend the Open GL module, to adaptively mesh CSG primitive objects, according to their size and transformation into screen space.

(c) Open GL for CSG [advanced, depends on (a) and (b)]

Extend the Open GL module to handle CSG combination operators.

Destructive solid geometry (DSG)
[depends on Software-z buffer or Open-GL interface]

(a) DSG for polygons [medium]

Implement Naylors extension to BSP to create solid objects that are defined by planar faces.

(b) Adaptive conversion of CSG primitive objects to DSG [medium, depends on (a)]

Extend the DSG module, to adaptively convert CSG primitive objects, according to their size and transformation into screen space into DSG trees defining inside and outside.

(c) CSG using DSG [advanced, depends on (a) and (b)]

Extend the DSG module to handle CSG combination operators.

NURBS surfaces for raytracing

[master's thesis]

Reflection models

The Strauss model [simple]

The Lafortune model [simple]

The Cook-Torrance model [medium]

The Ward model [medium]

The He-Torrance-Sillion-Greenberg reflection model

[master's thesis]

Perceptually driven radiosity

[master's thesis]

The photon map

[master's thesis]

Bidirectional path tracing

[master's thesis]

Metropolis light transport [depends on Bidirectional path tracing]

[master's thesis]

This page is maintained by Robert F Tobler. It was last updated on September 27, 1999.
If you have any comments, please send a message to rft@cg.tuwien.ac.at.