Editing Metropolis Light Transport

Warning: You are not logged in.

Your IP address will be recorded in this page's edit history.
The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then save the changes below to finish undoing the edit.
Latest revision Your text
Line 1: Line 1:
{{DesignDocument}}
 
 
 
The Metropolis Light Transport algorithm consists of a bidirectional path tracer and uses Monte Carlo method for randomly mutating the paths. Each mutation is accepted or rejected based on carefully chosen probability, which prevent a path that passes through an object to be accepted. Then an estimation is made by sampling many paths, and recording their locations on the image plane.
 
The Metropolis Light Transport algorithm consists of a bidirectional path tracer and uses Monte Carlo method for randomly mutating the paths. Each mutation is accepted or rejected based on carefully chosen probability, which prevent a path that passes through an object to be accepted. Then an estimation is made by sampling many paths, and recording their locations on the image plane.
  
Line 17: Line 15:
 
== Implementation ==
 
== Implementation ==
  
 +
=== Design Details ===
 
The algorithm will be written in C, so there would be no need for additional classes defining points and vectors and no compatibility issues. The structures already present, that define the basic types, such as points, vectors and data structures, will be used. Code will be written in src/rt.  
 
The algorithm will be written in C, so there would be no need for additional classes defining points and vectors and no compatibility issues. The structures already present, that define the basic types, such as points, vectors and data structures, will be used. Code will be written in src/rt.  
  
=== Bidirectional Path Tracer ===
+
==== Bidirectional Path Tracer ====
  
 
The path tracer will use rt_shootray() function to create paths. The paths will reflect and mutate based on a reflection model and the already implemented Phong Model and shaders can be used to handle that.
 
The path tracer will use rt_shootray() function to create paths. The paths will reflect and mutate based on a reflection model and the already implemented Phong Model and shaders can be used to handle that.
Line 25: Line 24:
 
The BPT is a two pass algorithm, with two rays being shot - one from the camera and the other from the light source). Since creating and reflecting the paths will work basically the same way, there shouldn't be any problems to use the same functions to do both.
 
The BPT is a two pass algorithm, with two rays being shot - one from the camera and the other from the light source). Since creating and reflecting the paths will work basically the same way, there shouldn't be any problems to use the same functions to do both.
  
=== Path Mutation ===
+
==== Path Mutation ====
  
 
This is the heart of the MLT algorithm - the random mutations on the paths. The mutations can be accepted or rejected based on probability and/or reflection models.
 
This is the heart of the MLT algorithm - the random mutations on the paths. The mutations can be accepted or rejected based on probability and/or reflection models.
Line 57: Line 56:
 
== Milestones ==
 
== Milestones ==
  
# Implementation of a bidirectional path tracer - including correct determination of obstacles in the path (by using librt functions).
+
1. Implementation of a bidirectional path tracer - including correct determination of obstacles in the path (by using librt functions).
## Initial design, rt_shootray() function will be used to shoot rays and detect collision.
+
1.1. Initial design, rt_shootray() function will be used to shoot rays and detect collision.
## Implement, using step 1.1, the path tracing function, that will record the points where the rays hit (structure hit).
+
1.2. Implement, using step 1.1, the path tracing function, that will record the points where the rays hit (structure hit).
## Use the reflection model and implement it in the path tracing function.
+
1.3. Use the reflection model and implement it in the path tracing function.
## Implement a way for the algorithm to detect how to connect the paths.
+
1.4. Implement a way for the algorithm to detect how to connect the paths.
# Implement the path mutation algorithm.
+
 
## Implement existing nodes mutation.
+
2. Implement the path mutation algorithm.
## Implement new nodes mutation.
+
2.1. Implement existing nodes mutation.
# Implement an algorithm to sample each pixel - including correctly detecting the coordinates in the 2D image of the path vertexes.
+
2.2. Implement new nodes mutation.
# Assemble those milestones together in the implementation of the final algorithm.
+
 
 +
3. Implement an algorithm to sample each pixel - including correctly detecting the coordinates in the 2D image of the path vertexes.
 +
 
 +
4. Assemble those milestones together in the implementation of the final algorithm.
  
 
----
 
----
Line 72: Line 74:
 
== Timeline ==
 
== Timeline ==
  
(log available at http://andrecastelo.wordpress.com/)
+
Until May 26th: studying the source code, getting familiar with the mentors and studying the MLT and the Bidirectional Path Tracer algorithm.
 
+
*Until May 26th: studying the source code, getting familiar with the mentors and studying the MLT and the Bidirectional Path Tracer algorithm.
+
  
*From May 26th to June 20th: implementation of an efficient bidirectional path tracer:
+
From May 26th to June 20th: implementation of an efficient bidirectional path tracer:
  
*From June 20th to July 1st: implementation of the path mutation algorithm. It will use pseudo random numbers in order to mutate the nodes.
+
From June 20th to July 1st: implementation of the path mutation algorithm. It will use pseudo random numbers in order to mutate the nodes.
  
*From July 1st to July 15th: implementation of the algorithm to sample each pixel. The paths will start from the screen and from the light source. If path nodes could hold information about the starting pixel, this would be easier.
+
From July 1st to July 15th: implementation of the algorithm to sample each pixel. The paths will, in theory, start from the screen and from the light source. If path nodes could hold information about the starting pixel, this would be easier.
  
*From July 15th to August 1st: assembly of the parts and implementation of the final MLT algorithm.
+
From July 15th to August 1st: assembly of the parts and implementation of the final MLT algorithm.
  
*From August 1st to August 18th: this period will be used to fix the remaining bugs, write documentation and/or implement any missing features.
+
From August 1st to August 18th: this period will be used to fix the remaining bugs, write documentation and/or implement any missing features.

Please note that all contributions to BRL-CAD may be edited, altered, or removed by other contributors. If you do not want your writing to be edited mercilessly, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource (see BRL-CAD:Copyrights for details). Do not submit copyrighted work without permission!

Cancel | Editing help (opens in new window)

Template used on this page: