So, we’ve been busy building a good light stage during the last week. We captured some rotating heads (including our professor’s) and ran them through our Structure From Motion pipeline (using Point-Based Multiview Stereo), which could now be run on several machines in the computer rooms. Steven wrote a script to automate the tasks of testing several subsets of the captured frames. We captured the heads using a (sub-HD) 720p camera and a regular camera with multi-shot functionality. Please note that no projection or markers were made onto the test subjects, the only input there is are the frames themselves.
These are all point clouds, we’re still experimenting with the best ways to mesh them. More results to follow.
Here are some PBRT renders I made, to compare between using photon mapping and using regular raybouncing. I recompiled PBRT with the advanced Photon Mapping Integrator (C++ code available here) to speed up the Final Gathering algorithm. There’s still a lot of noise in the final image, but the caustics are clearly visible.
I’ve also made a (failed) attempt at subsurface scattering, but it’s a nice render anyway:
Using Vertex Buffer Objects to transfer my mesh data (vertices, normals, curvatures) directly into GPU memory using STATIC_DRAW_ARB pointers just tripled the performance of my GLSL shader implementation.
Running a heavy model (+300k vertices) drawn with contours and suggestive contours at 24 fps, average.
The current plan for my thesis is to compare several implementations I made, which all have the same purpose: draw contours and suggestive contours on a given mesh, as fast as possible, as correct as possible. It’s time to review the status of the current builds of these different tools. All of them are written in C++ using OpenGL. Additional libraries are (free)GLUT (for windowing), GLEW (for extension loading) and Trimesh2 (for efficient vertex/mesh operations).
Read more behind the cut.
Continue reading »
I’ve implemented the pick-some-random-faces-algorithm (the algorithm formerly known as the Markosian algorithm, from this paper) for suggestive contours too now. Results are a bit better when it comes to framerate, with the big gains of course in models with more faces. For example, of the 40000 faces of the skull, only testing 400 for contours and 400 for suggestive contours gives the following (you can see my nifty FPS counter there too).
Continue reading »
I’ve been implementing an alternative CPU algorithm to draw contours last week. It was pitched by Markosian et. al, and I based my implementation on this Siggraph 2008 class by D. Decarlo.
Instead of testing all faces of a mesh for contours, I only test a configurable amount of random faces. When a contour is found, it is followed as far as possible. The algorithm in its pure form would only deliver good results at large sets of selected faces.
What’s interesting is to keep the seeds (the faces where you found the start of a contour line) of the previous frame. Using this in the next frame render, a high consistency can be achieved, and nearly all contour lines are found in the next frames.
Continue reading »
This is starting to be a weekly issue. Today’s edition: find the rabbit.
Today I rewrote parts of Trimesh2′s Mesh Viewer to work with GLSL-shaders. I implemented a simple cartoon shader. This is still pretty basic, since it doesn’t involve sending information back and forth between OpenGL and the shader.
Still, here is the result.
Still needs filtering and optimization, but it’s a first step.
Continue reading »
