球谐光照,球谐函数介绍

球谐光照,球谐函数介绍推导 球谐函数是球面坐标系下的拉普拉斯方程 f x y z 0 的泊松方程 中角度部分的解 这里参考 球谐函数 自己手推一遍 从笛卡尔坐标系到球坐标系的推导过程 可以参考 https wenku baidu com view f6c75dd2da38 html

大家好,我是讯享网,很高兴认识大家。

///


讯享网

从笛卡尔坐标系到球坐标系的推导过程,可以参考:https://wenku.baidu.com/view/f6c75dd2da38376baf1faec3.html

然后主要是分离变量法,考虑

 

虚数域的公式有如下推导,参考 complex analysis - In the real spherical harmonics, where does the sqrt(2) factor come from? - Mathematics Stack Exchange 

比如 UE 里的  SHBasisFunction3,能看到它基本和上面直角坐标系中的表达式一一对应,传进去normal,然后返回出来三阶球谐

FThreeBandSHVector SHBasisFunction3(half3 InputVector)
{
    FThreeBandSHVector Result;
    // These are derived from simplifying SHBasisFunction in C++
    Result.V0.x = 0.f; 
    Result.V0.y = -0.f * InputVector.y;
    Result.V0.z = 0.f * InputVector.z;
    Result.V0.w = -0.f * InputVector.x;
 
    half3 VectorSquared = InputVector * InputVector;
    Result.V1.x = 1.092548f * InputVector.x * InputVector.y;
    Result.V1.y = -1.092548f * InputVector.y * InputVector.z;
    Result.V1.z = 0.f * (3.0f * VectorSquared.z - 1.0f);
    Result.V1.w = -1.092548f * InputVector.x * InputVector.z;
    Result.V2 = 0.f * (VectorSquared.x - VectorSquared.y);
 
    return Result;
}
性质
开始应用之前,首先需要了解一下球谐函数的几个很重要的性质

1.正交完备性

2.旋转不变性 

它的旋转不变不是说怎么转都不变,而是说假定它的旋转变换是 r(x),我可以先计算旋转再计算球谐 f(r(x)),也可以先计算球谐之后再旋转,也就是  f(r(x)) = r(f(x))

这个的应用一个在于本身采样球是可以旋转的,旋转之后,不用重复计算球谐系数,另外一个在于可以进行空间变换,比如local space 到 world space 的旋转变换,比如有些应用会把球谐系数记录在模型的顶点上,由于是预处理的,一般是local space的,运行时需要转换到 world space,而由于球谐是旋转不变的,因此光照结果不会出错

3.低频高频的问题

经常看到是说球谐适合模拟低频部分的光照信息,比如间接光照,不适合表达高光或者反射等高频的光照信息,对于低频高频,我个人的理解是如下图所示

像图中,所示 m=0 的伴随勒得让多项式 的不同的 l 阶的曲线,阶数越高,频率越高,变化越高,就越能表达更高频的信息(频率高的基底,也只能表达高频信息),而由于一般实际应用,最多应用3到6阶的球谐,并不足以表达高频信息,所以一般会说球谐适合表达低频信息,高频的可以考虑用小波变换来表示

4.光照函数和传输函数的积分可以转变成它们之间球谐系数的点积,将积分变点乘,大幅简化了计算

传输函数 Tranfer Function 这个概念经常在 PRT(Precompute Radiance Transfer) 提到,我个人的理解是它是对入射照度 Light(x) 进行变换操作的函数,不管是 Lambert 里面的一个 cos,还是标准 BRDF公式 里的 FDG,它们都可以变成传输函数,只是说有些传输函数本身需要的是高频信息,而一般的球谐函数只用有限阶数,适合来表现一些低频信息,不太适合表现高频信息,所以有些函数不会去用球谐表示,而这个特性要做的是说,每种传输函数本来计算都是要组合起来然后积分的,现在都可以各自预计算各自的 球谐系数,然后运行时可以把积分变成系数之间的点积操作,大幅简化了运行时的计算量。

总之有了传输函数,我们就可以表现更加复杂的光照情况,比如遮挡关系等等,而且不会带来很大计算量的开销

先是投影,一般是预计算的,

 

//

另外,这个图不错:Real Spherical Harmonics Figure Table Complex Radial Magnitude - Table of spherical harmonics - Wikipedia

《The Gritty Details》中也列出了0~2阶球谐基函数:

 

 What is the geometric meaning of the inner product of two functions? - Mathematics Stack Exchange

 

至此,你应该理解两条重要结论:

  1. 球谐函数是拉普拉斯方程分离�变量后,角度部分通解的正交项(后面介绍正交性)。
  2. 如何计算球谐函数,可以参见等式(15)(20)(21)。

球谐性质

接着,讨论归一化的球谐函数的性质,它具备两条重要的性质构成了它应用的基石:

  • 正交完备性
  • 旋转不变性

正交完备性

对于任意两个归一化的球谐函数在球面上的积分有

投影的过程就是计算函数积分,计算消耗较大,可以采用离线处理来生成广义傅里叶系数;在实时渲染时,就要简单的线性组合,就可以重建原始函数。当然,由于是有限个系数,就必然存在误差。

我们再来看下连带勒让德函数,如图2所示,随着次数的增加,函数的振动频率会越快。对于函数的展开而言,振动频率越大的基底,它就只能表示越高频的信息,往往一个函数里面的高频信息量是较少的。

 

对于高维矩阵的构造方法非常的复杂,采用的是魏格纳d矩阵(Wigner d-matrices),可以参见文献[4]的讨论,网上也有这个算法的高效实现,有兴趣可以研究研究,参见SHTns。

附录

根据等式(15)的递归关系,就可以很容易计算出连带勒让德函数[3]。

double P(int l,int m,double x) { // evaluate an Associated Legendre Polynomial P(l,m,x) at x double pmm = 1.0; if(m>0) { double somx2 = sqrt((1.0-x)*(1.0+x)); double fact = 1.0; for(int i=1; i<=m; i++) { pmm *= (-fact) * somx2; fact += 2.0; } } if(l==m) return pmm; double pmmp1 = x * (2.0*m+1.0) * pmm; if(l==m+1) return pmmp1; double pll = 0.0; for(int ll=m+2; ll<=l; ++ll) { pll = ( (2.0*ll-1.0)*x*pmmp1-(ll+m-1.0)*pmm ) / (ll-m); pmm = pmmp1; pmmp1 = pll; } return pll; } 

讯享网

根据等式(20)(21),可以计算出球谐函数[3]。

讯享网double K(int l, int m) { // renormalisation constant for SH function double temp = ((2.0*l+1.0)*factorial(l-m)) / (4.0*PI*factorial(l+m)); return sqrt(temp); } double SH(int l, int m, double theta, double phi) { // return a point sample of a Spherical Harmonic basis function // l is the band, range [0..N] // m in the range [-l..l] // theta in the range [0..Pi] // phi in the range [0..2*Pi] const double sqrt2 = sqrt(2.0); if(m==0) return K(l,0)*P(l,m,cos(theta)); else if(m>0) return sqrt2*K(l,m)*cos(m*phi)*P(l,m,cos(theta)); else return sqrt2*K(l,-m)*sin(-m*phi)*P(l,-m,cos(theta)); } 

在D3D中实现的球谐系数的旋转D3DXSHRotate的实现为:

FLOAT* WINAPI D3DXSHRotate(FLOAT *out, UINT order, const D3DXMATRIX *matrix, const FLOAT *in) { FLOAT alpha, beta, gamma, sinb, temp[36], temp1[36]; TRACE("out %p, order %u, matrix %p, in %p\n", out, order, matrix, in); out[0] = in[0]; if ((order > D3DXSH_MAXORDER) || (order < D3DXSH_MINORDER)) return out; if (order <= 3) { out[1] = matrix->u.m[1][1] * in[1] - matrix->u.m[2][1] * in[2] + matrix->u.m[0][1] * in[3]; out[2] = -matrix->u.m[1][2] * in[1] + matrix->u.m[2][2] * in[2] - matrix->u.m[0][2] * in[3]; out[3] = matrix->u.m[1][0] * in[1] - matrix->u.m[2][0] * in[2] + matrix->u.m[0][0] * in[3]; if (order == 3) { FLOAT coeff[]={ matrix->u.m[1][0] * matrix->u.m[0][0], matrix->u.m[1][1] * matrix->u.m[0][1], matrix->u.m[1][1] * matrix->u.m[2][1], matrix->u.m[1][0] * matrix->u.m[2][0], matrix->u.m[2][0] * matrix->u.m[2][0], matrix->u.m[2][1] * matrix->u.m[2][1], matrix->u.m[0][0] * matrix->u.m[2][0], matrix->u.m[0][1] * matrix->u.m[2][1], matrix->u.m[0][1] * matrix->u.m[0][1], matrix->u.m[1][0] * matrix->u.m[1][0], matrix->u.m[1][1] * matrix->u.m[1][1], matrix->u.m[0][0] * matrix->u.m[0][0], }; out[4] = (matrix->u.m[1][1] * matrix->u.m[0][0] + matrix->u.m[0][1] * matrix->u.m[1][0]) * in[4]; out[4] -= (matrix->u.m[1][0] * matrix->u.m[2][1] + matrix->u.m[1][1] * matrix->u.m[2][0]) * in[5]; out[4] += 1.f * matrix->u.m[2][0] * matrix->u.m[2][1] * in[6]; out[4] -= (matrix->u.m[0][1] * matrix->u.m[2][0] + matrix->u.m[0][0] * matrix->u.m[2][1]) * in[7]; out[4] += (matrix->u.m[0][0] * matrix->u.m[0][1] - matrix->u.m[1][0] * matrix->u.m[1][1]) * in[8]; out[5] = (matrix->u.m[1][1] * matrix->u.m[2][2] + matrix->u.m[1][2] * matrix->u.m[2][1]) * in[5]; out[5] -= (matrix->u.m[1][1] * matrix->u.m[0][2] + matrix->u.m[1][2] * matrix->u.m[0][1]) * in[4]; out[5] -= 1.f * matrix->u.m[2][2] * matrix->u.m[2][1] * in[6]; out[5] += (matrix->u.m[0][2] * matrix->u.m[2][1] + matrix->u.m[0][1] * matrix->u.m[2][2]) * in[7]; out[5] -= (matrix->u.m[0][1] * matrix->u.m[0][2] - matrix->u.m[1][1] * matrix->u.m[1][2]) * in[8]; out[6] = (matrix->u.m[2][2] * matrix->u.m[2][2] - 0.5f * (coeff[4] + coeff[5])) * in[6]; out[6] -= (0.f * (coeff[0] + coeff[1]) - 1.f * matrix->u.m[1][2] * matrix->u.m[0][2]) * in[4]; out[6] += (0.f * (coeff[2] + coeff[3]) - 1.f * matrix->u.m[1][2] * matrix->u.m[2][2]) * in[5]; out[6] += (0.f * (coeff[6] + coeff[7]) - 1.f * matrix->u.m[0][2] * matrix->u.m[2][2]) * in[7]; out[6] += (0.f * (coeff[9] - coeff[8] + coeff[10] - coeff[11]) - 0.f * (matrix->u.m[1][2] * matrix->u.m[1][2] - matrix->u.m[0][2] * matrix->u.m[0][2])) * in[8]; out[7] = (matrix->u.m[0][0] * matrix->u.m[2][2] + matrix->u.m[0][2] * matrix->u.m[2][0]) * in[7]; out[7] -= (matrix->u.m[1][0] * matrix->u.m[0][2] + matrix->u.m[1][2] * matrix->u.m[0][0]) * in[4]; out[7] += (matrix->u.m[1][0] * matrix->u.m[2][2] + matrix->u.m[1][2] * matrix->u.m[2][0]) * in[5]; out[7] -= 1.f * matrix->u.m[2][2] * matrix->u.m[2][0] * in[6]; out[7] -= (matrix->u.m[0][0] * matrix->u.m[0][2] - matrix->u.m[1][0] * matrix->u.m[1][2]) * in[8]; out[8] = 0.5f * (coeff[11] - coeff[8] - coeff[9] + coeff[10]) * in[8]; out[8] += (coeff[0] - coeff[1]) * in[4]; out[8] += (coeff[2] - coeff[3]) * in[5]; out[8] += 0.f * (coeff[4] - coeff[5]) * in[6]; out[8] += (coeff[7] - coeff[6]) * in[7]; } return out; } if (fabsf(matrix->u.m[2][2]) != 1.0f) { sinb = sqrtf(1.0f - matrix->u.m[2][2] * matrix->u.m[2][2]); alpha = atan2f(matrix->u.m[2][1] / sinb, matrix->u.m[2][0] / sinb); beta = atan2f(sinb, matrix->u.m[2][2]); gamma = atan2f(matrix->u.m[1][2] / sinb, -matrix->u.m[0][2] / sinb); } else { alpha = atan2f(matrix->u.m[0][1], matrix->u.m[0][0]); beta = 0.0f; gamma = 0.0f; } D3DXSHRotateZ(temp, order, gamma, in); rotate_X(temp1, order, 1.0f, temp); D3DXSHRotateZ(temp, order, beta, temp1); rotate_X(temp1, order, -1.0f, temp); D3DXSHRotateZ(out, order, alpha, temp1); return out; } static void rotate_X(FLOAT *out, UINT order, FLOAT a, FLOAT *in) { out[0] = in[0]; out[1] = a * in[2]; out[2] = -a * in[1]; out[3] = in[3]; out[4] = a * in[7]; out[5] = -in[5]; out[6] = -0.5f * in[6] - 0.f * in[8]; out[7] = -a * in[4]; out[8] = -0.f * in[6] + 0.5f * in[8]; out[9] = -a * 0.f * in[12] + a * 0.f * in[14]; out[10] = -in[10]; out[11] = -a * 0.f * in[12] - a * 0.f * in[14]; out[12] = a * 0.f * in[9] + a * 0.f * in[11]; out[13] = -0.25f * in[13] - 0.f * in[15]; out[14] = -a * 0.f * in[9] + a * 0.f * in[11]; out[15] = -0.f * in[13] + 0.25f * in[15]; if (order == 4) return; out[16] = -a * 0.f * in[21] + a * 0.f * in[23]; out[17] = -0.75f * in[17] + 0.f * in[19]; out[18] = -a * 0.f * in[21] - a * 0.f * in[23]; out[19] = 0.f * in[17] + 0.75f * in[19]; out[20] = 0.375f * in[20] + 0.f * in[22] + 0.f * in[24]; out[21] = a * 0.f * in[16] + a * 0.f * in[18]; out[22] = 0.f * in[20] + 0.5f * in[22] - 0.f * in[24]; out[23] = -a * 0.f * in[16] + a * 0.f * in[18]; out[24] = 0.f * in[20] - 0.f * in[22] + 0.125f * in[24]; if (order == 5) return; out[25] = a * 0.f * in[30] - a * 0.f * in[32] + a * 0.f * in[34]; out[26] = -0.5f * in[26] + 0.f * in[28]; out[27] = a * 0.f * in[30] + a * 0.f * in[32] - a * 0.f * in[34]; out[28] = 0.f * in[26] + 0.5f * in[28]; out[29] = a * 0.f * in[30] + a * 0.f * in[32] + a * 0.f * in[34]; out[30] = -a * 0.f * in[25] - a * 0.f * in[27] - a * 0.f * in[29]; out[31] = 0.125f * in[31] + 0.f * in[33] + 0.f * in[35]; out[32] = a * 0.f * in[25] - a * 0.f * in[27] - a * 0.f * in[29]; out[33] = 0.f * in[31] + 0.8125f * in[33] - 0.f * in[35]; out[34] = -a * 0.f * in[25] + a * 0.f * in[27] - a * 0.f * in[29]; out[35] = 0.f * in[31] - 0.f * in[33] + 0.0f * in[35]; } FLOAT * WINAPI D3DXSHRotateZ(FLOAT *out, UINT order, FLOAT angle, const FLOAT *in) { UINT i, sum = 0; FLOAT c[5], s[5]; TRACE("out %p, order %u, angle %f, in %p\n", out, order, angle, in); order = min(max(order, D3DXSH_MINORDER), D3DXSH_MAXORDER); out[0] = in[0]; for (i = 1; i < order; i++) { UINT j; c[i - 1] = cosf(i * angle); s[i - 1] = sinf(i * angle); sum += i * 2; out[sum - i] = c[i - 1] * in[sum - i]; out[sum - i] += s[i - 1] * in[sum + i]; for (j = i - 1; j > 0; j--) { out[sum - j] = 0.0f; out[sum - j] = c[j - 1] * in[sum - j]; out[sum - j] += s[j - 1] * in[sum + j]; } if (in == out) out[sum] = 0.0f; else out[sum] = in[sum]; for (j = 1; j < i; j++) { out[sum + j] = 0.0f; out[sum + j] = -s[j - 1] * in[sum - j]; out[sum + j] += c[j - 1] * in[sum + j]; } out[sum + i] = -s[i - 1] * in[sum - i]; out[sum + i] += c[i - 1] * in[sum + i]; } return out; }

/

小讯
上一篇 2025-02-18 15:37
下一篇 2025-04-08 15:09

相关推荐

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/80503.html