Cycles: Implement denoising option for reducing noise in the rendered image
[blender.git] / intern / cycles / kernel / filter / filter_reconstruction.h
1 /*
2  * Copyright 2011-2017 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 CCL_NAMESPACE_BEGIN
18
19 ccl_device_inline void kernel_filter_construct_gramian(int x, int y,
20                                                        int storage_stride,
21                                                        int dx, int dy,
22                                                        int w, int h,
23                                                        int pass_stride,
24                                                        ccl_global float ccl_restrict_ptr buffer,
25                                                        ccl_global float *color_pass,
26                                                        ccl_global float *variance_pass,
27                                                        ccl_global float ccl_restrict_ptr transform,
28                                                        ccl_global int *rank,
29                                                        float weight,
30                                                        ccl_global float *XtWX,
31                                                        ccl_global float3 *XtWY,
32                                                        int localIdx)
33 {
34         int p_offset =  y    *w +  x;
35         int q_offset = (y+dy)*w + (x+dx);
36
37 #ifdef __KERNEL_CPU__
38         const int stride = 1;
39         (void)storage_stride;
40         (void)localIdx;
41         float design_row[DENOISE_FEATURES+1];
42 #elif defined(__KERNEL_CUDA__)
43         const int stride = storage_stride;
44         ccl_local float shared_design_row[(DENOISE_FEATURES+1)*CCL_MAX_LOCAL_SIZE];
45         ccl_local_param float *design_row = shared_design_row + localIdx*(DENOISE_FEATURES+1);
46 #else
47         const int stride = storage_stride;
48         float design_row[DENOISE_FEATURES+1];
49 #endif
50
51         float3 p_color = filter_get_pixel_color(color_pass + p_offset, pass_stride);
52         float3 q_color = filter_get_pixel_color(color_pass + q_offset, pass_stride);
53
54         float p_std_dev = sqrtf(filter_get_pixel_variance(variance_pass + p_offset, pass_stride));
55         float q_std_dev = sqrtf(filter_get_pixel_variance(variance_pass + q_offset, pass_stride));
56
57         if(average(fabs(p_color - q_color)) > 3.0f*(p_std_dev + q_std_dev + 1e-3f)) {
58                 return;
59         }
60
61         filter_get_design_row_transform(make_int2(x, y),       buffer + p_offset,
62                                         make_int2(x+dx, y+dy), buffer + q_offset,
63                                         pass_stride, *rank, design_row, transform, stride);
64
65         math_trimatrix_add_gramian_strided(XtWX, (*rank)+1, design_row, weight, stride);
66         math_vec3_add_strided(XtWY, (*rank)+1, design_row, weight * q_color, stride);
67 }
68
69 ccl_device_inline void kernel_filter_finalize(int x, int y, int w, int h,
70                                               ccl_global float *buffer,
71                                               ccl_global int *rank,
72                                               int storage_stride,
73                                               ccl_global float *XtWX,
74                                               ccl_global float3 *XtWY,
75                                               int4 buffer_params,
76                                               int sample)
77 {
78 #ifdef __KERNEL_CPU__
79         const int stride = 1;
80         (void)storage_stride;
81 #else
82         const int stride = storage_stride;
83 #endif
84
85         math_trimatrix_vec3_solve(XtWX, XtWY, (*rank)+1, stride);
86
87         float3 final_color = XtWY[0];
88
89         ccl_global float *combined_buffer = buffer + (y*buffer_params.y + x + buffer_params.x)*buffer_params.z;
90         final_color *= sample;
91         if(buffer_params.w) {
92                 final_color.x += combined_buffer[buffer_params.w+0];
93                 final_color.y += combined_buffer[buffer_params.w+1];
94                 final_color.z += combined_buffer[buffer_params.w+2];
95         }
96         combined_buffer[0] = final_color.x;
97         combined_buffer[1] = final_color.y;
98         combined_buffer[2] = final_color.z;
99 }
100
101 #undef STORAGE_TYPE
102
103 CCL_NAMESPACE_END