GPU Final: Final Project

Final project

Finished everything. Correct the bugs in Fresnel reflection and also the gamma correction. Some images of the result:

Figure 1. Image rendered with 600 seconds. All features turned on. 

 Figure 2. Rendered with 400 seconds. Focus on mirror sphere

Figure 3. Rendered with 400 seconds. Focus on icosahedron


The following are the resources related to this project. The paper is my favorite, also the demo with a voice over could explain details related to this project.

Source: https://github.com/duxing/GPUFinal
Paper: https://docs.google.com/open?id=0BxjlXUodntYuRkpYU1ZnVmdyYzA
Demo: http://www.youtube.com/watch?v=7x0vuwqoLeY&feature=youtu.be
Or http://vimeo.com/40990912

GPU Final: Week 6_2

This week I've been most working on the 660 final project. However I made something to show by now.

I made a few changes to the data structure and also fixed a small bug in my previous version. The changes are made mostly due to supporting new features.

The first thing added was Depth of Field. This part is done using a stochastic method based on purely physics. It's not computational heavy, cause I'm doing path tracing. If it has to be done in ray tracing, distributed ray tracing have to be used to generate a good result.
Here's a group of image showing lens with different focal plane (focus on different object).

Another feature is Fresnel refraction and reflection. I added this because I felt the transparent sphere in the scene seems weird, and then I realized that there should be reflection. This part is done also based on pure physics. Stochastic method is also used here to simulate different kinds of polarized light beams.

The third thing I did was analyzing the performance. Thanks to Varun, I learned to use Visual Profiler to see the detailed information of my program in run time, as well as occupancy calculator to find out the best block size for my program. Moreover, I changed the main PathTrace() function a little bit, and thus almost doubled the performance. In the previous version, I'm using a simpler scene and the fps is around 12, and now I've added a simple obj file into the scene, and rearranged the block size. The result is around 20 fps.

One last thing to say is I added a fps viewer. Showing not only the displaying frame rate(how frequently openGL is called draw function), but also the real rendering speed(how many layers rendered per second). In the process of adding this tool, I realized there's a certain need for my PathTrace() function to call cudaDeviceSynchronize(). And because I added this, the two frame rate displayed on the screen are almost the same all the time.

Here's two final image of my tracer. One takes 4 minutes to render and the other takes about 10 minutes. I just leave it running while writing this post.

Here's a image of previous version. No depth of field, no Fresnel equations, and also no obj files are added in the scene. You could make a comparison with former ones.

OK now I feel it's pretty much done for everything I thought possible to implement for final project. It's time to turn to my final paper and demo.

There's still lot's of future work to do, like continue with my previous cuda kdtree, and the image space photon mapping. This would definitely be my own projects during the summer.

GPU Final: Week 6

In the past week I've been working on my other final projects, and the only thing I did related to the GPU final is fixing a problem with generating secondary rays. In the final week, I'll be working on the required paper and video. Also an analysis of my final project is included.
I'll keep updating if I got more ideas.

GPU Final: Week5

The path tracer is ready. I modified the basic structure supporting both point light and area light, also the algorithm for path tracing.

Because it has to run on the GPU, with each thread in charge of a pixel, I build a color stack for each thread for unwrap the recursion. After primary rays are shooted, based on the material it hits, different kinds of secondary rays are generated  and used for later loop.

The idea of this path tracer compared to photon mapping, is to use Monte Carlo method to approximate the natural light. For random number generate, I used the thrust library. Although I haven't finished the planned photon mapping tracer, I got pretty familiar with some of common parts of the thrust library.

Apart from the light part, transparency and reflectivity are added compared to the first version of this path tracer last friday. Also a bug related to shading has been fixed.

I guess it's pretty much done for my final project. I've been working on this final project for the whole past 4 weeks. I'll spend less time on this from now on and turn to other two final projects.

If possible I'll add more feature to this path tracer and update the blog with it. For the photon mapping part, I've already build a frame work for it, and finished the photon tracing and large node construction of KD tree. I'll definitely finish that in summer, when I don't have that much pressure from the three final projects which keep me away from necessary sleeping.

Here's a picture rendered from the path tracer.

Global illumination features like the caustic effect could be seen directly from the image. Yet it takes a few minutes to render a picture with such quality. In real time it's more like a spotted image.
I'll see if it's possible to make it faster for higher quality image.

GPU Final: Week 4_2

Since last post I've been working on GPU KD tree construction.

And I've been spending my whole past 4 days reading and implementing Kun Zhou's paper "Real-Time KD-Tree Construction on Graphics Hardware"

Good news is I've implemented part of the construction part. Bad news is that there's a few ambiguity in the paper and is not well illustrated. Based on the time I've already spent on this paper I made a prediction of how long it would take me to finish the KD tree part. Given the fact that I haven't started the other two final projects yet, I decided to do path tracing instead. The basis set up for photon mapping would be finished when I don't have that heavy coursework pressure.

So start off today I turned into path tracing. A preliminary result has come out, which come up with a nice rendered image but takes a few seconds to converge. Because I'm using a point light right now, the result looks a little bit dim.

I'll focus on tuning my framework to support other kind of lights in the coming days, and also dealing with reflection and transparency. Now the result only have diffuse part and is limited to effects like color bleeding.

I'll post a video when I'm satisfied with the result.

GPU Final: Week 4

ok. I admit I lied to you.

I said I won't be working this week on GPU final but I just cannot stop.

Things are going well but slowly. I've been spend the first few days trying to figure out how to build a KDtree on GPU for the scene. Then I found out that is too hard and too heavy paper reading. So in the following days I've been working on the photons parts.

By now the photons part has pretty much been done. Here's a video rendering all the photons out based on the same scene of ray tracer. It's still capable to running in real time with 40K photons.

For the next step, I'll start to build the KD tree for photons so that I could finish the gathering part way much faster. For the photon part I've been spend a whole day on stream compaction just because of a weird unknown system error which would only occur in debug mode. Damn it wasted me around 12 hours. Anyway I solved that problem.

I like this feeling of exploring unknown things. I wish I could get some good result next week. Good luck to me!HAHAHAHA

GPU Final: Week 3

The past week is a important week.

First I gave up implementing the ISPM paper using G3D engine. It's ill documented and too complicated to start off and come up with a real time photon mapping tracer. Anyway, spending 2 weeks trying to implement such a fancy paper is a good experience. And I gradually understand the idea of the whole paper and start to know how to implement it. Thanks professor Morgan McGuire, not only for presenting this good idea but also for his patient answer to my questions.

I tried to implement ISPM from scratch using GLSL, and set up a basic framework for it. Then I realize the data structure might be a big problem for GLSL, so I turned to CUDA instead. Also I wish to lower the difficulty of my project. ISPM would be too hard to implement within the given time.

So I planned to implement a GPU photon mapping tracer or path tracer. Now I've already build a GPU ray tracer. Because I thought the CPU ray tracer is ill-written in format and structure, I build this from scratch.
It is done using CUDA. The tool bar is a third party library called "AntTweakBar". It's pretty much done the ray tracing part. Now I'm thinking about turning it into a path tracer or a photon mapping tracer. In addition I'm reading GPU Kdtree construction papers recently.  For the past three weeks I've spend all my spare time on GPU. So this week I would have to stop focusing on GPU and turn to my 660 and 563 final projects instead.

Here's a short video showing my present result. It's a simple Cornell box and the resolution is full 1K.

GPU Final: Week 2

I got started on the final project last week.

Yet I've got other projects due so I got started on Friday. I spend the whole weekend on the final project. 

Begin with the getting familiar with G3D engine. I studied the starter code carefully, and doing so to the raytrace and shader sample code. Now what I'm capable to build a scene and rendered with OpenGL, also GLSL could be used if I want to.

Yet designing the structure needed for photon mapping, and taking advantage of GPU is not a trivial task. 

I'll spend this week on this part.

Because G3D engine provide data file import as well as several famous scene and objects, I guess what my final scene would be a stanford bunny in the scene sponza.

The paper present a impressive idea, but in implementation, it's far more difficult than I thought. Good luck to myself.

GPU Final: Week 1

Sorry for being late in updating.

In the past week, I've been preparing for interviewing blue sky animation studio, and did not spend much time on the GPU final.

I've read the paper twice more, and have basically understood how the whole process worked. Also I referred to the author's website, where suggestion of implementation had been listed.

So to implement, I would based on a physics engine called G3D recommended by the paper author. I've setup the environment for the G3D library, and it could functioning properly on my computer right now.

For next step, I'll start off to get familiar with the G3D library and design the data structure needed for implementing the paper. Recently I've been pretty busy in preparing for 3 final projects, 2 homework assignments, 2 presentations and also a few possible internship position. I hope I could finish all the miscellaneous stuff  as soon as possible and focus on all my final projects.

Pitch for GPU programming final

    I've always been interested in Computer Graphics, especially global illumination. And among all the existing global illumination algorithms, photon mapping is the one I like best. So for the final project of GPU programming course, I'm planning to implement photon mapping on GPU with the help of hardware to do the accelerating work. My goal is to make photon mapping “real-time” somehow, and interactive so that it could be used in game industry.

By searching for papers related to my idea, I found one really attractive paper, and the real time photon mapping result represented in the demo is exactly what I want.

  

The paper I would refer to is "Hardware-Accelerated Global Illumination by Image Space Photon Mapping". Basically, the method used here, Image Space Photon Mapping (ISPM), is an extension of traditional photon mapping, tuning its most expensive steps to be amenable to GPU acceleration. It treats the whole photon mapping process as photons emitted from light source and bouncing several times into the pinhole camera. The most time-consuming procedure is the first bounce and the last bounce, which stands for direct illumination and final gathering respectively. And the method used is to use bounce map for light source in calculating on GPU the result of first bounce, which contains the most photons in photon spraying. Also it changes the gathering process by scattering, making it suitable to be executed on.

Honestly speaking I’ve not understand all the details in the paper, but the main idea is innovative enough to astonish me. My plan for implementing the paper could be conclude in steps as follows. First is to understand the whole procedure of the paper in detail, and design a corresponding framework capable to show the result. As mentioned in the paper the demo was based on a game engine, which is hard for me to build upon, so designing a good framework is significant. Next step would be implementing the algorithm based on the framework. And in my anticipation, C++, CUDA programming, OpenGL and GLSL would be languages and tools used here for implementation. The last step would be tuning and testing the performance.

If available time is possible after these, I would also like to make a comparison of performance between GPU accelerated version and the CPU version to see how much performance enhancing could be achieved.

Here is the paper and the demo attached:

Paper: http://dl.acm.org/citation.cfm?id=1572783

Demo: http://www.youtube.com/watch?v=GckOkpeJ3BY