實時降噪（Real-time Denoising）：Nvidia Real-time Denoisers 源碼剖析

目錄

Nvidia Real-time Denoisers（NRD） v3.x

版本：NRD v3.4.0

NRD 是工業界內比較先進的降噪器，被實際應用於 Watch Dogs: Legion 和 Cyberpunk 2077 等遊戲，然而網上關於 NRD 里降噪技術的具體介紹太少了，於是啃一啃源碼，並且總結出了這篇剖析部落格。

image-20220901130522601

圖左：輸入 1 spp 的 Diffuse 訊號和 0.5 spp 的 specular 訊號

圖右：ReBLUR 降噪後的輸出

image-20220903164227852

圖左：輸入 1 spp 的 Shadows 訊號

圖右：SIGMA 降噪後的輸出

ReBLUR 前置知識

空間濾波（Spatial Filtering）：Diffuse & Specular

泊松分布樣本（poisson samples）

採用泊松分布樣本，可以使用更少的樣本數：

image-20220826003224537

自適應半徑（adaptive radius）

取決於：

  • accumulated frames 的數量：accumulated frames 越多意味著當前 pixel 的雜訊干擾越小（結果更準確），就可以把模糊半徑調小

  • hit dist：如果 hit dist 比較長，那麼周圍的 shading point 大概率也會 hit 到該地方，因此把模糊半徑調大

  • 不需要參考時序上或者空間上的 variance

這樣就可以讓丟失歷史資訊的 pixel（即 accumulated frames 不多）更多呈現出模糊而不是雜訊。

程式碼：

float GetBlurRadius(
    float radius, float radiusBias, float radiusScale,
    float hitDistFactor, float nonLinearAccumSpeed,
    float roughness = 1.0
)
{
    // Scale down if accumulation goes well, keeping some non-zero scale to avoid under-blurring
    float r = lerp( gMinConvergedStateBaseRadiusScale, 1.0, nonLinearAccumSpeed );
    // Avoid over-blurring on contact ( tests 76, 95, 120 )
    hitDistFactor = lerp( hitDistFactor, 1.0, nonLinearAccumSpeed );
    r *= hitDistFactor; // TODO: reduce influence if reprojection confidence is low?

    // IMPORTANT: do not apply "hitDistFactor" to radiusBias because it is responsible for error compensation
    // Main composition
    r = radius * r + max( radiusBias, 2.0 * roughness ); // TODO: it would be good to get rid of "max"
    r *= radiusScale;
    // Modify by lobe spread
    r *= GetSpecMagicCurve2( roughness ); // TODO: roughness at hit needed
    // Disable spatial filtering if radius is 0
    r *= float( radius != 0 );
    return r; // TODO: if luminance stoppers are used, blur radius should depend less on hitDistFactor
}

效果：

image-20220825200534694

模糊權重（blur weight）

權重考慮的因素（有些是需要聯合考慮的）：

  • geometry ：沿平面方向的距離相差太大，權重調低
  • normal ：法線相差太大，以至於夾角大過 specular lobe 的半形就拒絕該樣本
  • hit distance ：hit distance 相差太大，權重調低
  • roughness（僅 specular）：roughness 相差太大，或者 roughness 太小（期望 specular 不那麼多模糊），權重調低
  • direction and pdf（可選） ：direction = L，而 NoL 越大，說明這個方向接受的光照越強，越應該參考它，權重調高。但為了能量守恆，必須還得除於一個 pdf。

sampling space & anisotropic sampling

不同的 brdf lobe，應該在不同的 取樣空間（sampling space） 進行取樣：

  • 對於 specular 物體來說，更應該在 view 為法線的平面中（其實就是傳統 screen-space）進行模糊：符合直覺
  • 對於 diffuse 來說，則更需要對以 n 為法線的平面上來進行模糊：在 tangent 平面可以保留更多 glancing angle 下的細節

image-20220825200656664

為此，可以統一 specular 和 diffuse 的取樣平面計算方法：

  • 根據 roughness 來決定取樣平面的朝向和半徑
  • 在實現中，就是通過算出平面的切線 \(T\) 和副切線 \(B\) 來表示這個平面的朝向和半徑

取樣平面改進效果：

image-20220825200849805

此外，只要讓取樣平面拉伸或斜偏（skew）成類橢圓狀，就能實現 各向異性取樣（anisotropic sampling）：

切線 \(T\) 和副切線 \(B\) 不是 normalized 的，它們的 length 分別代表了這個橢圓平面的短軸長度和長軸長度。

  • 越接近 glancing angle ，\(T\) 的 length 就會越大
  • roughness 決定了斜偏的程度

image-20220825201101601

程式碼（包含取樣平面 & anisotropic sampling）：

float2x3 GetKernelBasis( float3 D, float3 N, float NoD, float worldRadius, float roughness = 1.0, float anisoFade = 1.0 )
{
    float3x3 basis = STL::Geometry::GetBasis( N );
    float3 T = basis[ 0 ];
    float3 B = basis[ 1 ];
    if( roughness < 0.95 && NoD < 0.999 )
    {
        float3 R = reflect( -D, N );
        T = normalize( cross( N, R ) );
        B = cross( R, T );
        float skewFactor = lerp( roughness, 1.0, NoD );
        T *= lerp( skewFactor, 1.0, anisoFade );
    }
    T *= worldRadius;
    B *= worldRadius;
    return float2x3( T, B );
}

anisotropic sampling 效果：

image-20220826115222673

時間濾波（Temporal Filtering）：Diffuse

surface motion

當前幀 pixel \(x\) 進行 back projection 後的位置 \(x_{prev}\)，在大部分情況下都不會剛好處於像素的中心（也就是有一定子像素偏移），這時候就需要通過訪問其相鄰 4 個 pixels 的屬性進行加權混合就能得到 \(x_{prev}\) 對應的屬性。

surface motion：這 4 個歷史幀的 pixels 相當於組成了一個歷史幀 surface，而這些組成 surface 的 pixels 也被稱為 footprints。

當前幀沒有 surface，因此默認這裡出現的 surface 術語都是指歷史幀的。

surface 至少需要包含以下資訊：

  • previous 4×4 viewZ：實際只會用到 2×2 個
  • previous 2×2 normal
  • previous 2×2 materialID
  • previous 2×2 diffuse accum speed
  • previous 2×2 specular accum speed

image-20220826122249659

下一步就是需要 計算各 footprint 的權重：

  1. 對每個 footprint 都做了以下一種或兩種測試，然後輸出自定義權重 smbOcclusion0 ：

    • 遮擋測試（occlusion test）：檢查當前的 plane 是否與 previous plane 的距離相差不遠

    • ID測試（material ID test）：檢查當前的 material id 是否和 previous material ID 一樣

    自定義權重的 x,y,z,w 分別代表第 1,2,3,4 個 footprint 是否通過 occlusion test + material id test。

  2. 通過 uv 坐標得到各個 footprint 的雙線性插值（bilinear）權重。

    bilinear 權重和自定義權重直接相乘後就能得到各 footprint 的最終權重：

float4 GetBilinearCustomWeights(Bilinear f, float4 customWeights)
{
    float2 oneMinusWeights = 1.0 - f.weights;
    float4 weights = customWeights;
    weights.x *= oneMinusWeights.x * oneMinusWeights.y;
    weights.y *= f.weights.x * oneMinusWeights.y;
    weights.z *= oneMinusWeights.x * f.weights.y;
    weights.w *= f.weights.x * f.weights.y;
    return weights;
}

順便地，再另外計算一下 \(x_{prev}\) 的 quality（也就是用于衡量這個 surface 有多少參考價值，它決定了 temporal 的歷史混合係數）：

quality = 0 為不具有參考性（意味著 4 個 footprints 都沒通過 test），quality = 1 為極度具有參考性。

  1. 直接對 smbOcclusion0 應用雙線性插值，就能得到 \(x_{prev}\) 的 quality
  2. 順便用 sqrt01 函數把 quality 往上提一下
float footprintQualityWithMaterialID = STL::Filtering::ApplyBilinearFilter( smbOcclusion0.z, smbOcclusion1.y, smbOcclusion2.y, smbOcclusion3.x, smbBilinearFilter );
footprintQualityWithMaterialID = STL::Math::Sqrt01( footprintQualityWithMaterialID );

歷史權重（history weight）

控制 diffuse temporal 混合係數的主要因素：

  • diffAccumSpeed（即 accumulated frames 的數量）
  • footprintQualityWithMaterialID（x_prev 的品質）

接著通過 bilinear custom weights 算出四個 footprint 的權值，就可以加權混合它們的 accum speed 得到 \(x_{prev}\) 的 accum speed：

// 計算出各個 footprint 的最終權值
float4 smbOcclusionWeightsWithMaterialID = STL::Filtering::GetBilinearCustomWeights( smbBilinearFilter, float4( smbOcclusion0.z, smbOcclusion1.y, smbOcclusion2.y, smbOcclusion3.x ) );
....
// AdvanceAccumSpped：加權混合 prevDiffAccumSpeeds 得到 diffAccumSpeed
float diffAccumSpeed = AdvanceAccumSpeed( prevDiffAccumSpeeds, gDiffMaterialMask ? smbOcclusionWeightsWithMaterialID : smbOcclusionWeights );
// 根據 quality 和 diffAccumSpeed，調整 diffAccumSpeed
diffAccumSpeed *= lerp( gDiffMaterialMask ? footprintQualityWithMaterialID : footprintQuality, 1.0, 1.0 / ( 1.0 + diffAccumSpeed ) );

最終，temporal 就是根據 \(x_{prev}\) 的 accum speed（並限制在最多 32 幀）混合，輸出結果：

\[\text { Output }=\text { lerp }\left(\text { History }, \text { Input }, \frac{1}{1+A}\right)
\]

\(A\) 為 accum speed（accumulated frames）的數量

float diffAccumSpeedNonLinear = 1.0 / ( min( diffAccumSpeed, gMaxAccumulatedFrameNum ) + 1.0 );
ReBLUR_TYPE diffResult = MixHistoryAndCurrent( smbDiffHistory, diff, diffAccumSpeedNonLinear );

此外，源碼中還有個 fast history 選項：實際上就是將 accum speed 限制在更少的幀數（fast accum speed），從而歷史混合權重更小，滯後效應更小，但可能閃爍嚴重。

時間濾波（Temporal Filtering）：Specular

surface motion

計算 surface motion 的流程，對於 specular 和 diffuse 來說基本是一樣的。

surface motion confidence

但是 surface 對 diffuse 和 sepcular 的參考價值各不同：

  • 對於 diffuse 來說， surface motion 往往就是最具有參考價值的，其具體品質由 footprintQualityWithMaterialID 決定。
  • 對於 specular 來說， surface motion 往往具有更低的參考價值，因為 specular 與很多因素相關，我們還需要除了 footprintQualityWithMaterialID 以外的其它衡量因素，如: parallax, nov, roughness（這些因素的可以合稱為 surface motion confidence）

parallax ：定義為新觀察方向 \(V\) 與舊觀察方向 \(V_{prev}\) 的偏差。

在觀察的物體不移動旋轉的情況下，如果 camera 不移動而只是旋轉，那麼 parallax = 0，此時直接的 back projection 是不會產生任何 artifacts 的。

image-20220830161921285

// Parallax
float smbParallax = ComputeParallax( 
    Xprev - gCameraDelta.xyz, 					// 相當於 V_prev
    gOrthoMode == 0.0 ? pixelUv : smbPixelUv,	// X 在當前裁剪空間的位置，實際上也代表了 V
    gWorldToClip,
    gRectSize, 
    gUnproject, 
    gOrthoMode
);

float ComputeParallax( float3 X, float2 uvForZeroParallax, float4x4 mWorldToClip, float2 rectSize, float unproject, float orthoMode )
{
    // 將 V_prev 變換到裁剪空間中
    float3 clip = STL::Geometry::ProjectiveTransform( mWorldToClip, X ).xyw;
    clip.xy /= clip.z;
    clip.y = -clip.y;
    float2 uv = clip.xy * 0.5 + 0.5;
    
    float invDist = orthoMode == 0.0 ? rsqrt( STL::Math::LengthSquared( X ) ) : rcp( clip.z );
	
    // 計算 V_prev 與 V 之間的偏差
    float2 parallaxInUv = uv - uvForZeroParallax;
    float parallaxInPixels = length( parallaxInUv * rectSize );
    float parallaxInUnits = PixelRadiusToWorld( unproject, orthoMode, parallaxInPixels, clip.z );
    float parallax = parallaxInUnits * invDist;

    return parallax * NRD_PARALLAX_NORMALIZATION;
}

diffuse 與 view 無關，但 specular 與 view 相關；相鄰兩幀間的 view 可能發生偏差，導致 \(x_{prev}\) 的 specular 對當前幀 pixel \(x\) 的 specular 參考價值變低。

也就是說，parallax 越大就說明 surface motion 這個歷史資訊越不可靠：

  • 歷史混合權重應該更低
  • 應用更寬的 variance clamping（源碼未實現）

作者認為對於乾淨的 hit-dist 輸入訊號，variance 會比較小，從而 clamping 會十分有用。可惜在 ReBLUR pipeline 中，Pre-blur 還不足以保證輸出訊號的充分降噪，因此不太適合使用 clamping，強行使用只會浪費性能。

在最後計算 smbSpecAccumSpeed（即 accumulated frames 的數量）的時候會用到形如下的函數 f，即 GetSpecAccumSpeed：

\(A=f(A,n\cdot v,parallex)\)

  • roughness：對於 roughness 很小的情況下，\(f\) 的輸出會更小
  • parallax：對於 parallax 很大（即兩幀之間視角差別很大時）的情況下，\(f\) 的輸出會更小
  • nov：\(f\) 的輸出應當比 \(n\cdot v\) 的絕對值更小（surface motion 本身沒有考慮菲涅爾效應）

ps：\(f\) 輸出越小，那麼歷史混合權重就越小

float GetSpecAccumSpeed( float maxAccumSpeed, float roughness, float NoV, float parallax, float curvature, float viewZ )
{
    // Artificially increase roughness if parallax is low to get a few frames of accumulation // TODO: is there a better way?
    float smbParallaxNorm = SaturateParallax( parallax * REBLUR_PARALLAX_SCALE );
    roughness = roughness + saturate( 0.05 - roughness ) * ( 1.0 - smbParallaxNorm );

    // Recalculate virtual roughness from curvature
    float pixelSize = PixelRadiusToWorld( gUnproject, gOrthoMode, 1.0, viewZ );
    float curvatureAngleTan = abs( curvature ) * pixelSize * gFramerateScale;

    float percentOfVolume = 0.75;
    float roughnessFromCurvatureAngle = STL::Math::Sqrt01( curvatureAngleTan * ( 1.0 - percentOfVolume ) / percentOfVolume );

    roughness = lerp( roughness, 1.0, roughnessFromCurvatureAngle );

    float acos01sq = saturate( 1.0 - NoV * 0.99999 ); // see AcosApprox()
    float a = STL::Math::Pow01( acos01sq, REBLUR_SPEC_ACCUM_CURVE );
    float b = 1.1 + roughness * roughness;
    float parallaxSensitivity = ( b + a ) / ( b - a );

    float powerScale = 1.0 + parallaxSensitivity * parallax * REBLUR_PARALLAX_SCALE; // TODO: previously was REBLUR_PARALLAX_SCALE => gFramerateScale
    float accumSpeed = GetSpecAccumulatedFrameNum( roughness, powerScale );
    accumSpeed = min( accumSpeed, maxAccumSpeed );
    return accumSpeed * float( gResetHistory == 0 );
}

virtual motion

這個方法和 2021 reliable motion vector 的 glossy motion vector 是相似的思路。

上面說到 surface motion 有時候可能對 specular 的參考價值不大，因為它的思路是跟蹤著色點，而我們更應該跟蹤反射點（specular 貢獻最大的地方），於是就需要另一種方式計算出的參考位置，也就是 virtual motion。

virtual motion，核心是通過 hit dist 和 view 算出虛像的位置 \(x_{virtual}\)，然後 previous camera 和虛像的位置連線後相交於以 \(x\) 為準的平面，就能得到前一幀反射點 \(virtualPrev\) ，這個點便是我們更應該參考的點，因為它往往是反射最強烈的點（在鏡面反射情形下它就是最佳參考點）。

虛像是指物體沿反射平面翻轉後形成的虛假形象，它與反射點相連恰恰就是 view 的方向。這是使用虛像是為了方便計算，不然對著實像去做 motion，又得引入各種額外的 reflect 等計算。

image-20220830190820608

// 用於說明，非源碼
float3 Xvirtual = X - V * hitDist;
float2 pixelUvVirtualPrev = GetScreenUv( gWorldToClipPrev , Xvirtual );

然而實際上的 specular 不可能全部都是 mirror reflection（roughness = 0），也就是說它的 lobe 可能是胖一些的（roughness>0）：

image-20220830154657608

對於非 mirror reflection 的 lobe，我們希望應該參考反射稍弱一些的地方，因此可以根據 roughness 來調整 \(x_{virtual}\) 的位置：roughness 越大，那麼就讓它越靠近表面的 \(x\)，從而得到更加偏離反射點的 \(virtualPrev\)。

image-20220830191727558

// 用於說明，非源碼
float f = GetSpecularDominantFactor(NoV, roughness);
float3 Xvirtual = X - V * hitDist * f;
float2 pixelUvVirtualPrev = GetScreenUv( gWorldToClipPrev , Xvirtual );

這個根據 roughness 來決定的距離比例函數 GetSpecularDominantFactor 如下：

float GetSpecularDominantFactor(float NoV, float linearRoughness, compiletime const uint mode = STL_SPECULAR_DOMINANT_DIRECTION_DEFAULT)
{
    float dominantFactor;
    if (mode == STL_SPECULAR_DOMINANT_DIRECTION_G2)
    {
        float a = 0.298475 * log(39.4115 - 39.0029 * linearRoughness);
        dominantFactor = Math::Pow01(1.0 - NoV, 10.8649) * (1.0 - a) + a;
    }
    else if (mode == STL_SPECULAR_DOMINANT_DIRECTION_G1)
        dominantFactor = 0.298475 * NoV * log(39.4115 - 39.0029 * linearRoughness) + (0.385503 - 0.385503 * NoV) * log(13.1567 - 12.2848 * linearRoughness);
    else
    {
        float s = 1.0 - linearRoughness;
        dominantFactor = s * (Math::Sqrt01(s) + linearRoughness);
    }
    return saturate(dominantFactor);
}

virtual motion confidence

對於 specular 來說，surface motion 可以通過 parallax, nov, roughness 等來衡量它的可參考性，而 virtual motion 的參考價值也不是完美的，因此也需要有 virtual motion confidence 來衡量它的可參考性：

  • hit dist：如果 hit dist 變化不大，那麼增強一些 confidence
// Virtual motion confidence
float smbHitDist = ExtractHitDist( lerp( spec, smbSpecHistory, STL::Math::SmoothStep( 0.04, 0.11, roughnessModified ) ) ); // see tests 114 and 138
smbHitDist *= hitDistScale;

float vmbHitDist = ExtractHitDist( vmbSpecHistory );
vmbHitDist *= _ReBLUR_GetHitDistanceNormalization( dot( vmbViewZs, 0.25 ), gHitDistParams, vmbRoughness );

float3 smbXvirtual = GetXvirtual( NoV, smbHitDist, curvature, X, Xprev, V, dominantFactor );
float2 uv1 = STL::Geometry::GetScreenUv( gWorldToClipPrev, smbXvirtual, false );
float3 vmbXvirtual = GetXvirtual( NoV, vmbHitDist, curvature, X, Xprev, V, dominantFactor );
float2 uv2 = STL::Geometry::GetScreenUv( gWorldToClipPrev, vmbXvirtual, false );

float hitDistDeltaScale = min( specAccumSpeed, 10.0 ) * lerp( 1.0, 0.5, saturate( gSpecPrepassBlurRadius / 5.0 ) ); // TODO: is it possible to tune better?
float deltaParallaxInPixels = length( ( uv1 - uv2 ) * gRectSize );
float virtualMotionHitDistWeight = saturate( 1.0 - hitDistDeltaScale * deltaParallaxInPixels );
  • prev prev：計算出 \(x_{prev}\) 位置與 \(x_{virtual}\) 位置的單位位移方向（delta），然後從 \(x_{virtual}\) 往 delta 方向移動若干次（源碼迭代次數為2次），每次停留下來的點拿去檢測：如果 normal 變化不大，那麼增強一些 confidence

這個操作主要是為了解決在光滑平面接受粗糙表面 radiance 的 failure case，裡面實際上還綜合考慮了 viewz，roughness，具體可看源碼。

image-20220901164503769

// Virtual motion confidence - fixing trails if radiance on a flat surface is taken from a sloppy surface
float2 virtualMotionDelta = vmbPixelUv - smbPixelUv;
virtualMotionDelta *= STL::Math::Rsqrt( STL::Math::LengthSquared( virtualMotionDelta ) );
virtualMotionDelta /= gRectSizePrev;
virtualMotionDelta *= saturate( smbParallaxInPixels / 0.1 ) + smbParallaxInPixels;

float virtualMotionPrevPrevWeight = 1.0;
[unroll]
for( uint i = 1; i <= ReBLUR_VIRTUAL_MOTION_NORMAL_WEIGHT_ITERATION_NUM; i++ )
{
	float2 vmbPixelUvPrev = vmbPixelUv + virtualMotionDelta * i;

	float4 vmbNormalAndRoughnessPrev = UnpackNormalAndRoughness( gIn_Prev_Normal_Roughness.SampleLevel( gLinearClamp, vmbPixelUvPrev * gRectSizePrev * gInvScreenSize, 0 ) );
	float3 vmbNprev = STL::Geometry::RotateVector( gWorldPrevToWorld, vmbNormalAndRoughnessPrev.xyz );

	float w = GetEncodingAwareNormalWeight( N, vmbNprev, angle + curvatureAngle * i );

	float wr = GetEncodingAwareRoughnessWeights( roughness, vmbNormalAndRoughnessPrev.w, roughnessFraction );
	w *= lerp( 0.25 * i, 1.0, wr );

	// Ignore pixels from distant surfaces
	// TODO: with this addition test 3e shows a leak from the bright wall
	float vmbZprev = UnpackViewZ( gIn_Prev_ViewZ.SampleLevel( gLinearClamp, vmbPixelUvPrev * gRectSizePrev * gInvScreenSize, 0 ) );
	float wz = GetBilateralWeight( vmbZprev, Xvprev.z );
	w = lerp( 1.0, w, wz );

	virtualMotionPrevPrevWeight *= IsInScreen( vmbPixelUvPrev ) ? w : 1.0;
	virtualMotionRoughnessWeight *= wr;
}

根據 virtual motion confidence，計算出 virtual motion 的 accum speed：

// Virtual motion - accumulation acceleration
float responsiveAccumulationAmount = GetResponsiveAccumulationAmount( roughness );
float vmbSpecAccumSpeed = GetSpecAccumSpeed( specAccumSpeed, lerp( 1.0, roughnessModified, responsiveAccumulationAmount ), 0.99999, 0.0, 0.0, 1.0 );

float smc = GetSpecMagicCurve2( roughnessModified, 0.97 );
vmbSpecAccumSpeed *= lerp( smc, 1.0, virtualMotionHitDistWeight );
vmbSpecAccumSpeed *= virtualMotionPrevPrevWeight;

如果 virtual motion confidence 比較低，那麼還可以再給 surface motion 的 accum speed 額外調高些：

// Surface motion - allow more accumulation in regions with low virtual motion confidence ( test 9 )
float roughnessBoost = ( 0.1 + 0.3 * roughnessModified ) * ( 1.0 - roughnessModified );
float roughnessBoostAmount = virtualHistoryAmount * ( 1.0 - virtualMotionRoughnessWeight );
float roughnessBoosted = roughnessModified + roughnessBoost * roughnessBoostAmount;
float smbSpecAccumSpeed = GetSpecAccumSpeed( specAccumSpeed, roughnessBoosted, NoV, smbParallax, curvature, viewZ );

歷史權重（history weight）

有了基於 surface motion 計算出來的 smbSpecAccumSpeed 和基於 virtual motion 計算出來的 vmbSpecAccumSpeed，用於計算出兩種 motion 方式的混合比例：

// Fallback to surface motion if virtual motion doesn't go well
virtualHistoryAmount *= saturate( ( vmbSpecAccumSpeed + 0.1 ) / ( smbSpecAccumSpeed + 0.1 ) );

根據混合比例，混合出 specular 歷史 color 和 accum speed：

REBLUR_TYPE specHistory = lerp( smbSpecHistory, vmbSpecHistory, virtualHistoryAmount );
// Accumulation with checkerboard resolve // TODO: materialID support?
specAccumSpeed = InterpolateAccumSpeeds( smbSpecAccumSpeed, vmbSpecAccumSpeed, virtualHistoryAmount );

最終，和 diffuse temporal filtering 相似，根據 \(x_{prev}\) 的 accum speed（並限制在最多 32 幀）混合，輸出結果：

\[\text { Output }=\text { lerp }\left(\text { History }, \text { Input }, \frac{1}{1+A}\right)
\]

實際上，這裡的混合還是和 diffuse temporal filtering 有所不同，因為這裡還額外用 roughness 去稍微限制一下混合權重，具體可看源碼。個人猜測理由是：specular 訊號相比 diffuse 訊號在時間域上的變化更加高頻，因此不易太多 accumulation（低頻化）。

float specAccumSpeedNonLinear = 1.0 / ( min( specAccumSpeed, gMaxAccumulatedFrameNum ) + 1.0 );
REBLUR_TYPE specResult = MixHistoryAndCurrent( specHistory, spec, specAccumSpeedNonLinear, roughnessModified );

ReBLUR Diffuse-Specular Pipeline

image-20220829145853863

ps：反向的箭頭是指上一幀的輸出資訊被 temporal 所利用

其它功能：

  • performance mode（性能模式）：主要就是關閉了 History fix 的相當部分程式碼，增速至約 1.25 倍
  • 支援 Checkerboard Resolve（棋盤式渲染），即 0.5 SPP 訊號
  • 支援輸入 Occlusion 訊號，可以做額外實現 AO 降噪這個附加功能

Pass 1: Pre-blur

其實就是 spatial filtering：

  • 使用固定的半徑（實際上取決於 hit dist）：對原始輸入影像去做一個初步的降噪，從而粗略的完成 outliers removal

Pass 2: Accumulation

其實就是 temporal filtering，其所需的歷史幀資訊：

  • accum speed：成功累積的幀數，可以理解成對應的 fragment 已經在螢幕中存活了多久
  • viewz：深度
  • normal & roughness
  • material ID
  • diffuse color
  • specular color

可以看到 Accumulation 所需要的存儲和頻寬都比較大。

Pass 3: History Fix

有些 pixel 的 accumulated frames 數量很少（一般都是剛出現在螢幕0~3幀的 pixels），它只剩下初始的 1 spp 訊號（缺少歷史資訊，往往充滿雜訊），這時候就需要對其重建歷史：

  1. 取 3×3 周圍 pixels 的 accum speed 並進行混合得到該 pixel 的 accum speed
  2. 如果 accum speed 低於某個閾值，說明缺少歷史資訊，然後進行 5×5 的簡化版 spatial filtering 得到重建後（其實就希望用 blur 替代雜訊）的 diffuse/specular 訊號和 viewz

源程式碼中並沒有看到對 diffuse/specular 訊號或 viewz 生成了 mip，可能是原方法太過耗時，效果提升不大，不如乾脆就做一遍 blur。

此外，performance mode 相關的程式碼基本都在 History fix Pass，開啟 performance mode 可以加速 ReBLUR 性能到約 1.25 倍。

Pass 4: Blur & Pass 5: Post-blur

兩個 pass 也都是 spatial filtering：

  • 都是自適應半徑（取決於 accumulated frames 和 hit dist）
  • 但 Blur 使用較小的 radius scale，而 Post-blur 使用更大的 radius scale

為什麼 Blur 和 Post-Blur 兩個 Pass 幾乎沒區別，卻不合併成一個 Blur Pass，個人理解是跟 a-trous 思想類似，只不過這種方式只有兩層 Blur：

image-20220830142925435

Pass 6: Temporal Stabilization

temporal stabilization != temporal accumulation，而是類似 TAA 的 filter：

  • 基於 variance 的 clamping：相比 TAA 使用更寬的半徑範圍，clamp 掉的 history 以一定權重混合 current
  • 不引入額外的延遲

雖然看程式碼，大部分還是 temporal filtering 的內容，但是就是通過 anti-lag 的處理和 clamping 才實現了類似 TAA 的效果。

SIGMA 前置知識

Tile-based Denoising

可以將螢幕分成一塊塊 tile，如果 tile 內部有至少一個需要降噪的 pixel，則將該 tile 加入需要降噪的 tile 隊列。

對於 shadows 訊號，影像內其實含有大量無需降噪的 pixels（例如整塊 tile 都是被照亮的或者被遮擋的）：

image-20220829151637702

我們只需要對標記了的 tiles 進行降噪操作。

空間濾波（Spatial Filtering）：Shadows

估測 occluder 平均距離

hit dist 意味著 shading point 到 occluder 的距離，而由於每個 pixel 的 hit dist 往往是 noisy 的，而後面的模糊步驟需要依賴乾淨一些的 hit dist 資訊來指導，因此先做了一次螢幕空間上固定半徑的基於深度權重的 spatial filtering：

其實也順便 blur 了一下 visibility。

float sum = 0;
float hitDist = 0;
SIGMA_TYPE result = 0;
[unroll]
for( j = 0; j <= BORDER * 2; j++ )
{
	[unroll]
	for( i = 0; i <= BORDER * 2; i++ )
	{
		int2 pos = threadPos + int2( i, j );
		float2 data = s_Data[ pos.y ][ pos.x ];
		SIGMA_TYPE s = s_Shadow_Translucency[ pos.y ][ pos.x ];
		float h = data.x;
		float signNoL = float( data.x != 0.0 );
		float z = data.y;
		float w = 1.0;
		if( !( i == BORDER && j == BORDER ) )
		{
			w = GetBilateralWeight( z, viewZ );
			w *= saturate( 1.0 - abs( centerSignNoL - signNoL ) );
		}
		result += s * w;
		hitDist += h * float( s.x != 1.0 ) * w;
		sum += w;
	}
}
float invSum = 1.0 / sum;
result *= invSum;
hitDist *= invSum;

sampling space

與 diffuse 相似，對陰影模糊更應該在以 n 為法線的平面進行空間濾波（而非以 view 為法線的螢幕空間上）：

image-20220903160600506

在以 n 為法線的平面上分布的 poisson samples 還需要轉換回螢幕空間 uv 坐標以便訪問對應 pixel 的 visibility：

float2 GetKernelSampleCoordinates( float4x4 mToClip, float3 offset, float3 X, float3 T, float3 B, float4 rotator = float4( 1, 0, 0, 1 ) )
{
    #if( NRD_USE_QUADRATIC_DISTRIBUTION == 1 )
        offset.xy *= offset.z;
    #endif

    // We can't rotate T and B instead, because T is skewed
    offset.xy = STL::Geometry::RotateVector( rotator, offset.xy );

    float3 p = X + T * offset.x + B * offset.y;
    float3 clip = STL::Geometry::ProjectiveTransform( mToClip, p ).xyw;
    clip.xy /= clip.z;
    clip.y = -clip.y;

    float2 uv = clip.xy * 0.5 + 0.5;

    return uv;
}

SIGMA Shadow Pipeline

核心在於，輸入 shadows 訊號（是螢幕影像，而不是 shadowmap），每個 pixel 值代表了它的 visibility（可見性），對被標記的 tile 里的所有 pixels 做 2 次空間濾波 + 1 次時域濾波。

image-20220903163829653

一般來講，要使用 SIGMA，就要一個光源對場景生成一張螢幕影像，多個光源就得多張螢幕影像，因此應當只用在比較重要的主光源上。

SIGMA 方案與 PCF/PCSS 方案相比：

  • SIGMA 可以取代 PCF 或者 PCSS，通過空間濾波和時域濾波的方式直接模糊掉 noise
  • SIGMA 理論上性能比 PCF/PCSS 要好（有空得對比實測一下），因為藉助 tile-based 特性大量剔除了無關計算

Pass 1: Classify Tiles

將螢幕分成若干個 tiles，對每個 tile ：

  • 檢測內部共 256 個 pixels 是否同時全被照亮或者同時全被遮擋：若不滿足，則將該 tile 標記成應當 denosing
  • tile 內部每個 pixel 根據 hit dist 計算出 world radius（hit dist 越長往往更容易處於半影處），同時計算它投影在螢幕上的大小 pixel radius，並且比較並記錄本 tile 中最大的 pixel radius 為 max radius。

Pass 2: Pre-blur & Pass 3: Blur

類似於 ReBLUR 的 Blur & Post-blur（兩層空間濾波），不過每個 Pass 開頭，先對 hit dist 和 visibility 做了一個固定半徑的基於深度權重的粗糙模糊，接著才開始更正式的模糊：

  • 根據 hit dist 和 Pass 1 計算出的 max radius 決定模糊半徑
  • 模糊權重基本上只考慮了 geometry 因素

Pass 4: Temporal Stabilization

類似於 ReBLUR 的 temporal stabilization，都是 TAA 效果：

  • 基於 variance 的 clamping
  • 不引入額外的延遲

ReLAX

主要是基於 SVGF + a-trous 的思路來做，然後對 diffuse 和 specular 兩種訊號分別進行了優化（在 ReBLUR 也能找到這些優化的蹤影），核心是對 clamping 進行優化從而實現 fast history，對 RTXDI 的訊號更加適用。

在 GI 中，實際性能與沒開性能模式的 ReBLUR 差不多，且大部分場景下品質也不如性能模式下的 ReBLUR，因此此處就不深入剖析其源碼了，推薦還是使用 ReBLUR+SIGMA。

總結

性能表現：

  • RTX 3090，2K 解析度：
    • ReBLUR = 2.72 ms

image-20220902171129912

  • 個人實測：RTX2060，2K 解析度，純跑光線追蹤 20+ ms：
    • ReBLUR = ReLAX = 10 ms
    • ReBLUR: performance mode = 7~8 ms = 1.25倍的提升
    • SIGMA = 2~3 ms

總的來說，NRD 通過利用了非常多的歷史資訊（導致高頻寬高存儲）和多層 spatial/temporal pass 去做出非常高品質的降噪效果。也就是說它太過重量級了，如果我們要實際應用於自己的光線追蹤訊號，可以適當參考 NRD 的一些技術點，設計出一個更輕量級的 denoising pipeline。

當然，它的各種工業界的 trick 也很厲害，各種小參數用不同的函數形式（甚至還用一些 magic curves）倒來倒去，最後來影響最主要的參數（半徑、權重之類）。

參考

Tags:

VirMach 便宜 VPS

QNews

QNews