将球体映射到立方体

Question

这里描述了一种将立方体映射到球体的特殊方法： http : //mathproofs.blogspot.com/2005/07/mapping-cube-to-sphere.html

这不是您基本的“标准化点，您就完成了”的方法，而是提供了更均匀间隔的映射。

我试图对从球体坐标到立方体坐标的映射进行逆运算，但一直无法得出工作方程。 这是一个相当复杂的方程组，有很多平方根。

有没有数学天才想尝试一下？

这是 C++ 代码中的方程：

sx = x * sqrtf(1.0f - y * y * 0.5f - z * z * 0.5f + y * y * z * z / 3.0f);

sy = y * sqrtf(1.0f - z * z * 0.5f - x * x * 0.5f + z * z * x * x / 3.0f);

sz = z * sqrtf(1.0f - x * x * 0.5f - y * y * 0.5f + x * x * y * y / 3.0f);

sx,sy,sz 是球体坐标，x,y,z 是立方体坐标。

Answer 1

我想为此归功于 gmatt，因为他做了很多工作。 我们的答案的唯一区别是 x 的方程。

要进行从球体到立方体的逆映射，首先要确定球体点投影到的立方体面。 这一步很简单 - 只需找到具有最大长度的球体向量的分量，如下所示：

// map the given unit sphere position to a unit cube position
void cubizePoint(Vector3& position) {
    double x,y,z;
    x = position.x;
    y = position.y;
    z = position.z;

    double fx, fy, fz;
    fx = fabsf(x);
    fy = fabsf(y);
    fz = fabsf(z);

    if (fy >= fx && fy >= fz) {
        if (y > 0) {
            // top face
            position.y = 1.0;
        }
        else {
            // bottom face
            position.y = -1.0;
        }
    }
    else if (fx >= fy && fx >= fz) {
        if (x > 0) {
            // right face
            position.x = 1.0;
        }
        else {
            // left face
            position.x = -1.0;
        }
    }
    else {
        if (z > 0) {
            // front face
            position.z = 1.0;
        }
        else {
            // back face
            position.z = -1.0;
        }
    }
}

对于每个面 - 取表示为 s 和 t 的剩余立方体向量分量，并使用这些方程求解它们，这些方程基于表示为 a 和 b 的剩余球体向量分量：

s = sqrt(-sqrt((2 a^2-2 b^2-3)^2-24 a^2)+2 a^2-2 b^2+3)/sqrt(2)
t = sqrt(-sqrt((2 a^2-2 b^2-3)^2-24 a^2)-2 a^2+2 b^2+3)/sqrt(2)

您应该看到两个方程中都使用了内部平方根，因此该部分只执行一次。

这是最终函数，其中包含方程并检查 0.0 和 -0.0 以及正确设置立方体组件符号的代码 - 它应该等于球体组件的符号。

void cubizePoint2(Vector3& position)
{
    double x,y,z;
    x = position.x;
    y = position.y;
    z = position.z;

    double fx, fy, fz;
    fx = fabsf(x);
    fy = fabsf(y);
    fz = fabsf(z);

    const double inverseSqrt2 = 0.70710676908493042;

    if (fy >= fx && fy >= fz) {
        double a2 = x * x * 2.0;
        double b2 = z * z * 2.0;
        double inner = -a2 + b2 -3;
        double innersqrt = -sqrtf((inner * inner) - 12.0 * a2);

        if(x == 0.0 || x == -0.0) { 
            position.x = 0.0; 
        }
        else {
            position.x = sqrtf(innersqrt + a2 - b2 + 3.0) * inverseSqrt2;
        }

        if(z == 0.0 || z == -0.0) {
            position.z = 0.0;
        }
        else {
            position.z = sqrtf(innersqrt - a2 + b2 + 3.0) * inverseSqrt2;
        }

        if(position.x > 1.0) position.x = 1.0;
        if(position.z > 1.0) position.z = 1.0;

        if(x < 0) position.x = -position.x;
        if(z < 0) position.z = -position.z;

        if (y > 0) {
            // top face
            position.y = 1.0;
        }
        else {
            // bottom face
            position.y = -1.0;
        }
    }
    else if (fx >= fy && fx >= fz) {
        double a2 = y * y * 2.0;
        double b2 = z * z * 2.0;
        double inner = -a2 + b2 -3;
        double innersqrt = -sqrtf((inner * inner) - 12.0 * a2);

        if(y == 0.0 || y == -0.0) { 
            position.y = 0.0; 
        }
        else {
            position.y = sqrtf(innersqrt + a2 - b2 + 3.0) * inverseSqrt2;
        }

        if(z == 0.0 || z == -0.0) {
            position.z = 0.0;
        }
        else {
            position.z = sqrtf(innersqrt - a2 + b2 + 3.0) * inverseSqrt2;
        }

        if(position.y > 1.0) position.y = 1.0;
        if(position.z > 1.0) position.z = 1.0;

        if(y < 0) position.y = -position.y;
        if(z < 0) position.z = -position.z;

        if (x > 0) {
            // right face
            position.x = 1.0;
        }
        else {
            // left face
            position.x = -1.0;
        }
    }
    else {
        double a2 = x * x * 2.0;
        double b2 = y * y * 2.0;
        double inner = -a2 + b2 -3;
        double innersqrt = -sqrtf((inner * inner) - 12.0 * a2);

        if(x == 0.0 || x == -0.0) { 
            position.x = 0.0; 
        }
        else {
            position.x = sqrtf(innersqrt + a2 - b2 + 3.0) * inverseSqrt2;
        }

        if(y == 0.0 || y == -0.0) {
            position.y = 0.0;
        }
        else {
            position.y = sqrtf(innersqrt - a2 + b2 + 3.0) * inverseSqrt2;
        }

        if(position.x > 1.0) position.x = 1.0;
        if(position.y > 1.0) position.y = 1.0;

        if(x < 0) position.x = -position.x;
        if(y < 0) position.y = -position.y;

        if (z > 0) {
            // front face
            position.z = 1.0;
        }
        else {
            // back face
            position.z = -1.0;
        }
    }

所以，这个解决方案并不像立方体到球体映射那么漂亮，但它完成了工作！

感谢任何提高上述代码效率或阅读能力的建议！

--- 编辑 --- 我应该提到我已经对此进行了测试，到目前为止，在我的测试中，代码看起来是正确的，结果至少精确到小数点后第 7 位。 那是从我使用浮动时开始的，现在使用双打可能更准确。

--- 编辑 --- 这是 Daniel 优化的 glsl 片段着色器版本，以表明它不必是这么大的可怕功能。 Daniel 使用它来过滤立方体贴图上的采样！ 好点子！

const float isqrt2 = 0.70710676908493042;

vec3 cubify(const in vec3 s)
{
float xx2 = s.x * s.x * 2.0;
float yy2 = s.y * s.y * 2.0;

vec2 v = vec2(xx2 – yy2, yy2 – xx2);

float ii = v.y – 3.0;
ii *= ii;

float isqrt = -sqrt(ii – 12.0 * xx2) + 3.0;

v = sqrt(v + isqrt);
v *= isqrt2;

return sign(s) * vec3(v, 1.0);
}

vec3 sphere2cube(const in vec3 sphere)
{
vec3 f = abs(sphere);

bool a = f.y >= f.x && f.y >= f.z;
bool b = f.x >= f.z;

return a ? cubify(sphere.xzy).xzy : b ? cubify(sphere.yzx).zxy : cubify(sphere);
}

Answer 2

经过一些重新排列后，您可以获得“漂亮”的表格

(1)   1/2 z^2 = (alpha) / ( y^2 - x^2) + 1
(2)   1/2 y^2 = (beta)  / ( z^2 - x^2) + 1
(3)   1/2 x^2 = (gamma) / ( y^2 - z^2) + 1

其中alpha = sx^2-sy^2 ， beta = sx^2 - sz^2和gamma = sz^2 - sy^2 。 自己验证一下。

现在我既没有动力也没有时间，但从这一点来看，它很容易解决：

1. 将（1）代入（2）。 重新排列 (2) 直到得到以下形式的多项式（根）方程

   (4) a(x) * y^4 + b(x) * y^2 + c(x) = 0

   这可以使用y^2的二次公式解决。 注意， a(x),b(x),c(x)是一些功能x 。 二次公式为 (4) 生成 2 个根，您必须牢记这一点。

2. 使用 (1),(2),(4) 仅根据x^2计算出z^2的表达式。

3. 使用 (3) 写出以下形式的多项式根方程：

    (5) a * x^4 + b * x^2 + c = 0

   其中a,b,c不是函数而是常数。 使用二次公式解决这个问题。 总共您将有x^2,y^2,z^2对的 2*2=4 个可能解，这意味着您将有 4*2=8 个满足这些方程的可能x,y,z对的总解。 检查每个x,y,z对的条件并（希望）消除除一个以外的所有条件（否则不存在逆映射。）

祝你好运。

附注。 很可能逆映射不存在，想想几何：球体的表面积为4*pi*r^2而立方体的表面积为6*d^2=6*(2r)^2=24r^2如此直观，您在立方体上有更多点映射到球体。 这意味着多对一的映射，任何这样的映射都不是单射的，因此不是双射的（即映射没有逆。）对不起，但我认为你不走运。

- - - 编辑 - - - - - - -

如果您遵循 MO 的建议，设置z=1意味着您正在查看平面z=1中的实心正方形。

使用前两个方程求解 x,y，wolfram alpha 给出结果：

x = (sqrt(6) s^2 sqrt(1/2 (sqrt((2 s^2-2 t^2-3)^2-24 t^2)+2 s^2-2 t^2-3)+3)-sqrt(6) t^2 sqrt(1/2 (sqrt((2 s^2-2 t^2-3)^2-24 t^2)+2 s^2-2 t^2-3)+3)-sqrt(3/2) sqrt((2 s^2-2 t^2-3)^2-24 t^2) sqrt(1/2 (sqrt((2 s^2-2 t^2-3)^2-24 t^2)+2 s^2-2 t^2-3)+3)+3 sqrt(3/2) sqrt(1/2 (sqrt((2 s^2-2 t^2-3)^2-24 t^2)+2 s^2-2 t^2-3)+3))/(6 s)

和

y = sqrt(-sqrt((2 s^2-2 t^2-3)^2-24 t^2)-2 s^2+2 t^2+3)/sqrt(2)

上面我使用s=sx和t=sy ，我将使用u=sz 。 然后你可以使用你对u=sz的第三个方程。 也就是说，您想将球体的顶部映射到立方体。 然后对于任何0 <= s,t <= 1 （其中s,t在球体的坐标系中）然后元组(s,t,u)映射到(x,y,1) （这里x,y在立方体坐标系。）剩下的唯一事情就是让你弄清楚u是什么。 您可以通过使用s,t求解x,y然后使用x,y求解u来解决这个问题。

请注意，这只会立方体的上部仅映射到立方体顶面z=1 。 您必须对所有 6 个边（ x=1 、 y=1 、 z=0 ... 等）执行此操作。 我建议使用 wolfram alpha 来解决你为每个子案例得到的结果方程，因为它们会像上面的那些一样丑陋或更丑陋。

Answer 3

这个答案包含cube2sphere和sphere2cube没有a = 1的限制。 所以立方体的边2a从-a到a ，球体的半径是a 。

我知道这个问题已经过去 10 年了。 尽管如此，如果有人需要，我会给出答案。 实现是在Python中，

我使用(x, y, z)作为立方体坐标， (p, q, r)作为球体坐标和相关的下划线变量(x_, y_, z_)意味着它们是通过使用反函数生成的。

import math
from random import randint # for testing

def sign_aux(x):
    return lambda y: math.copysign(x, y)

sign = sign_aux(1) # no built-in sign function in python, I know...

def cube2sphere(x, y, z):
    if (all([x == 0, y == 0, z == 0])):
        return 0, 0, 0

    def aux(x, y_2, z_2, a, a_2):
        return x * math.sqrt(a_2 - y_2/2 - z_2/2 + y_2*z_2/(3*a_2))/a
    
    x_2 = x*x
    y_2 = y*y
    z_2 = z*z
    a = max(abs(x), abs(y), abs(z))
    a_2 = a*a

    return aux(x, y_2, z_2, a, a_2), aux(y, x_2, z_2, a, a_2), aux(z, x_2, y_2, a, a_2)

def sphere2cube(p, q, r):
    if (all([p == 0, q == 0, r == 0])):
        return 0, 0, 0
    def aux(s, t, radius):
        A = 3*radius*radius
        R = 2*(s*s - t*t)
        S = math.sqrt( max(0, (A+R)*(A+R) - 8*A*s*s) )  # use max 0 for accuraccy error
        iot = math.sqrt(2)/2
        s_ = sign(s) * iot * math.sqrt(max(0, A + R - S)) # use max 0 for accuraccy error
        t_ = sign(t) * iot * math.sqrt(max(0, A - R - S)) # use max 0 for accuraccy error
        return s_, t_
    
    norm_p, norm_q, norm_r = abs(p), abs(q), abs(r)
    norm_max = max(norm_p, norm_q, norm_r)
    radius = math.sqrt(p*p + q*q + r*r)
    if (norm_max == norm_p):
        y, z = aux(q, r, radius)
        x = sign(p) * radius
        return x, y, z
    if (norm_max == norm_q):
        z, x = aux(r, p, radius)
        y = sign(q) * radius
        return x, y, z
    x, y = aux(p, q, radius)
    z = sign(r) * radius
    return x, y, z

# measuring accuracy

max_mse = 0
for i in range(100000):
    x = randint(-20, 20)
    y = randint(-20, 20)
    z = randint(-20, 20)
    p, q, r = cube2sphere(x, y, z)
    x_, y_, z_ = sphere2cube(p, q, r)
    max_mse = max(max_mse, math.sqrt(((x-x_)**2 + (y-y_)**2 + (z-z_)**2))/3)
print(max_mse)

# 1.1239159602905078e-07

max_mse = 0
for i in range(100000):
    p = randint(-20, 20)
    q = randint(-20, 20)
    r = randint(-20, 20)
    x, y, z = sphere2cube(p, q, r)
    p_, q_, r_ = cube2sphere(x, y, z)
    max_mse = max(max_mse, math.sqrt(((p-p_)**2 + (q-q_)**2 + (r-r_)**2))/3)
print(max_mse)

# 9.832883321715792e-08

此外，我绘制了一些点以直观地检查函数，这些是结果。

Answer 4

这是您可以考虑的一种方式：对于球体中的给定点 P，取从原点开始、通过 P 并在立方体表面结束的线段。 令 L 为该段的长度。 现在您需要做的就是将 P 乘以 L； 这等价于映射 ||P|| 从区间 [0, 1] 到区间 [0, L]。 这种映射应该是一对一的——球体中的每个点都指向立方体中的一个唯一点（表面上的点留在表面上）。 请注意，这是假设单位球体和立方体； 这个想法应该在其他地方成立，你只需要涉及一些比例因素。

我已经掩盖了困难的部分（找到线段），但这是一个标准的光线投射问题。 有一些链接在这里解释如何计算这对于任意光线与轴对齐边界框; 您可能可以简化事情，因为您的光线从原点开始并到达单位立方体。 如果您需要帮助简化方程式，请告诉我，我会尝试一下。

Answer 5

如果您不害怕触发和 pi，看起来有一个更清洁的解决方案，但不确定它是否更快/可比。

确定人脸后，只需取出剩余的组件并执行：

u = asin ( x ) / half_pi
v = asin ( y ) / half_pi

这是一个直观的飞跃，但是这似乎支持它（虽然不完全一样的话题），所以请纠正我，如果我错了。

我懒得张贴解释原因的插图。 :D