Blender Git Commits

Render API: Preserve extended passes when using bordered rendering

Merge remote-tracking branch 'origin/master' into soc-2016-cycles_denoising

Conflicts:
intern/cycles/kernel/kernel_types.h

Cycles/Render API: Implement interactive updating while denoising

The tile highlighting is still a bit random and the progress bar isn't showing either,
but the basic live update works.
To avoid lots of duplicated code, editors/render and editors/space_image now share two functions.

Cycles: Fix Memory leak when denoising renderred images

Render API: Implement the denoising process as a job to keep the UI responsive

Cycles: Support denoising after rendering on CUDA

Cycles: Once again fix MSVC building

Apparently, MSVC doesn't like enum values being larger than 32 bit.
So, for now the enum entries are just #define'd instead.

Cycles: Add additional debugging output containing the estimated rMSE reduction per sample

Cycles: Fix 2-parameter least-squares helper function

Cycles: Fix artifacts in lower-left tile when denoising on the CPU

Cycles: Add experimental alternative SVD-threshold norm based on power iteration

One of the first steps of the algorithm is to apply a truncated SVD to a
matrix formed by the features in order to reduce the dimensionality of the
problem and decorrelate dimensions.

The truncation threshold, according to the paper, is defined by twice the
spectral norm of the matrix that is formed like the first one, but from the
variances of the features.

The reference implementation doesn't compute the spectral norm, but instead
computes the Frobenius norm and multiplies it with sqrt(Rank)/2.
That makes sense since it's guaranteed that the Frobenius norm lies somewhere
between the one and sqrt(Rank) times the spectral norm.

However, it's still an approximation. Therefore, in this commit I've tried
to directly compute the spectral norm since the runtime performance is currently
mainly limited by the per-pixel loops, so a small constant increase shouldn't matter too much.
In order to compute it, the code just constructs the Gramian matrix of the variance matrix
and computes the square root of its largest eigenvalue, which is found via power iteration.

I haven't tested the code too much yet, but it seems that the improvement is quite negligible
and not really worth the effort. Still, it might be interesting to tweak it further.

Merge remote-tracking branch 'origin/master' into soc-2016-cycles_denoising

Cycles: Fix denoising artifacts caused by Emission closures

Cycles: Fix denoising debug passes with CUDA

Cycles: Implement Postprocessing callback

This commit finally uses all the work from the earlier commits to implement
the postprocess callback, which triggers a denoising pass on the current
RenderResult.

Note that this does not work on GPUs yet - they can be used for rendering,
but the Device setting has to be switched to CPU rendering before using the
postprocess button.

One other remaining problem is that the Image editor view isn't updated automatically,
you have to switch to another pass/layer and back to see the change.

Also, the feature should eventually be implemeted as a Job to get a progress bar and a
responding UI during denoising.

Cycles: Add denoise-only mode the the Session

This mode just creates the Device, generates tiles and runs the denoising kernel
on each tile.
Compared to the regular mode of operation, a lot is missing: No interactivity, no
scene syncing, no progressive rendering etc. However, these features aren't needed
for the denoise-after-render feature, and so this mode saves a lot of code when
calling it from the bindings.

Internally, it uses one single large buffer to hold the image, instead of a small buffer
per tile. That requires some changes to the TileManager and is also the reason for the
earlier region-of-interest commit.

Cycles: Implement RenderResult -> RenderBuffers import

This commit adds a function that takes an existing RenderResult and copies the passes
to newly created RenderBuffers. That will later be used to copy the rendered image
back for post-processing denoising.

Cycles: Explicitly pass region of interest to RenderBuffers when exporting pixels to Blender

By itself, that change is pretty useless, but it's important for the upcoming denoise-after-render support.

Render API: Fix bugs regarding pass handling when Cycles debugging is enabled

The probem here was that regular passes are stored as (signed) integers.
Therefore, the pass with bit 31 set (the Cycles debug pass) is stored as -1.
On its own, that's fine - however, when that pass type is implicitly cast to uint64_t
in a function call, the compiler apparently first sign-extends it and then reinterprets
it as unsigned, so the result is 0xffffffff80000000 instead of only bit 31.
To get around that issue, the type is now explicitly cast to a unsigned int32 first and
then implicitly extended to uint64_t.

Cycles: Add additional debugging info to the denoiser