Konvertieren einer Cubemap in Equirectangular Panorama

Vorausgesetzt, die Eingabe-Bildes ist in den folgenden cubemap format:

Ziel ist es, das projizierte Bild auf der equirectangular-format etwa so:

Die Umwandlung Algorithmus ist Recht einfach.
Zur Berechnung der besten Schätzung der Farbe der einzelnen pixel in der equirectangular Bild gegeben, eine cubemap mit 6 Gesichter:

• Erstens, Berechnung von Polarkoordinaten entsprechen, die auf jeden pixel
  das sphärische Bild.
• Zweitens, mit Hilfe der Polarkoordinaten bilden einen Vektor und ermitteln auf
  das Gesicht der cubemap und die pixel, in Richtung des Vektors
  liegt; wie ein raycast vom Zentrum eines Würfels treffen würde, eine
  seine Seiten und einem bestimmten Punkt auf dieser Seite.

Beachten Sie, dass es mehrere Methoden zur Schätzung der Farbe eines pixels im equirectangular Bild gegeben, eine normierte Koordinate (u,v) auf eine bestimmte Fläche einer cubemap. Die einfachste Methode ist, das ist eine sehr grobe Näherung und wird in dieser Antwort der Einfachheit halber ist die Runde die Koordinaten auf einen bestimmten pixel und verwenden, die pixel. Anderen fortgeschrittenen Methoden rechnen konnte, ein Durchschnitt von ein paar benachbarte Pixel.

Die Implementierung des Algorithmus wird variieren, je nach Kontext. Ich habe eine schnelle Umsetzung in Unity3D C#, die zeigt, wie implementieren Sie den Algorithmus in einem realen Szenario. Es läuft auf der CPU, es gibt eine Menge Raum für Verbesserung, aber es ist leicht zu verstehen.

using UnityEngine;

public static class CubemapConverter
{
    public static byte[] ConvertToEquirectangular(Texture2D sourceTexture, int outputWidth, int outputHeight)
    {
        Texture2D equiTexture = new Texture2D(outputWidth, outputHeight, TextureFormat.ARGB32, false);
        float u, v; //Normalised texture coordinates, from 0 to 1, starting at lower left corner
        float phi, theta; //Polar coordinates
        int cubeFaceWidth, cubeFaceHeight;

        cubeFaceWidth = sourceTexture.width / 4; //4 horizontal faces
        cubeFaceHeight = sourceTexture.height / 3; //3 vertical faces


        for (int j = 0; j < equiTexture.height; j++)
        {
            //Rows start from the bottom
            v = 1 - ((float)j / equiTexture.height);
            theta = v * Mathf.PI;

            for (int i = 0; i < equiTexture.width; i++)
            {
                //Columns start from the left
                u = ((float)i / equiTexture.width);
                phi = u * 2 * Mathf.PI;

                float x, y, z; //Unit vector
                x = Mathf.Sin(phi) * Mathf.Sin(theta) * -1;
                y = Mathf.Cos(theta);
                z = Mathf.Cos(phi) * Mathf.Sin(theta) * -1;

                float xa, ya, za;
                float a;

                a = Mathf.Max(new float[3] { Mathf.Abs(x), Mathf.Abs(y), Mathf.Abs(z) });

                //Vector Parallel to the unit vector that lies on one of the cube faces
                xa = x / a;
                ya = y / a;
                za = z / a;

                Color color;
                int xPixel, yPixel;
                int xOffset, yOffset;

                if (xa == 1)
                {
                    //Right
                    xPixel = (int)((((za + 1f) / 2f) - 1f) * cubeFaceWidth);
                    xOffset = 2 * cubeFaceWidth; //Offset
                    yPixel = (int)((((ya + 1f) / 2f)) * cubeFaceHeight);
                    yOffset = cubeFaceHeight; //Offset
                }
                else if (xa == -1)
                {
                    //Left
                    xPixel = (int)((((za + 1f) / 2f)) * cubeFaceWidth);
                    xOffset = 0;
                    yPixel = (int)((((ya + 1f) / 2f)) * cubeFaceHeight);
                    yOffset = cubeFaceHeight;
                }
                else if (ya == 1)
                {
                    //Up
                    xPixel = (int)((((xa + 1f) / 2f)) * cubeFaceWidth);
                    xOffset = cubeFaceWidth;
                    yPixel = (int)((((za + 1f) / 2f) - 1f) * cubeFaceHeight);
                    yOffset = 2 * cubeFaceHeight;
                }
                else if (ya == -1)
                {
                    //Down
                    xPixel = (int)((((xa + 1f) / 2f)) * cubeFaceWidth);
                    xOffset = cubeFaceWidth;
                    yPixel = (int)((((za + 1f) / 2f)) * cubeFaceHeight);
                    yOffset = 0;
                }
                else if (za == 1)
                {
                    //Front
                    xPixel = (int)((((xa + 1f) / 2f)) * cubeFaceWidth);
                    xOffset = cubeFaceWidth;
                    yPixel = (int)((((ya + 1f) / 2f)) * cubeFaceHeight);
                    yOffset = cubeFaceHeight;
                }
                else if (za == -1)
                {
                    //Back
                    xPixel = (int)((((xa + 1f) / 2f) - 1f) * cubeFaceWidth);
                    xOffset = 3 * cubeFaceWidth;
                    yPixel = (int)((((ya + 1f) / 2f)) * cubeFaceHeight);
                    yOffset = cubeFaceHeight;
                }
                else
                {
                    Debug.LogWarning("Unknown face, something went wrong");
                    xPixel = 0;
                    yPixel = 0;
                    xOffset = 0;
                    yOffset = 0;
                }

                xPixel = Mathf.Abs(xPixel);
                yPixel = Mathf.Abs(yPixel);

                xPixel += xOffset;
                yPixel += yOffset;

                color = sourceTexture.GetPixel(xPixel, yPixel);
                equiTexture.SetPixel(i, j, color);
            }
        }

        equiTexture.Apply();
        var bytes = equiTexture.EncodeToPNG();
        Object.DestroyImmediate(equiTexture);

        return bytes;
    }
}

Zur Nutzung der GPU, die ich erstellt einen shader, der die gleiche Umwandlung. Es ist viel schneller als laufen die conversion-pixel für pixel auf, die CPU aber leider die Einheit erlegt Auflösung Einschränkungen auf cubemaps, damit es seine Nützlichkeit beschränkt sich in Szenarien, wenn eine hohe Auflösung input-Bild verwendet werden.

Shader "Conversion/CubemapToEquirectangular" {
  Properties {
        _MainTex ("Cubemap (RGB)", CUBE) = "" {}
    }

    Subshader {
        Pass {
            ZTest Always Cull Off ZWrite Off
            Fog { Mode off }      

            CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                #pragma fragmentoption ARB_precision_hint_fastest
                //#pragma fragmentoption ARB_precision_hint_nicest
                #include "UnityCG.cginc"

                #define PI    3.141592653589793
                #define TWOPI 6.283185307179587

                struct v2f {
                    float4 pos : POSITION;
                    float2 uv : TEXCOORD0;
                };

                samplerCUBE _MainTex;

                v2f vert( appdata_img v )
                {
                    v2f o;
                    o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
                    o.uv = v.texcoord.xy * float2(TWOPI, PI);
                    return o;
                }

                fixed4 frag(v2f i) : COLOR 
                {
                    float theta = i.uv.y;
                    float phi = i.uv.x;
                    float3 unit = float3(0,0,0);

                    unit.x = sin(phi) * sin(theta) * -1;
                    unit.y = cos(theta) * -1;
                    unit.z = cos(phi) * sin(theta) * -1;

                    return texCUBE(_MainTex, unit);
                }
            ENDCG
        }
    }
    Fallback Off
}

Die Qualität der entstehenden Bilder erheblich verbessert werden kann, indem entweder beschäftigt eine differenziertere Methode zur Schätzung der Farbe eines pixels während der Konvertierung oder Nachbearbeitung das resultierende Bild (oder beides, eigentlich). Zum Beispiel ein Bild der größeren Größe erzeugt werden, wenden Sie einen Unschärfe-filter und dann das Downsampling auf die gewünschte Größe.

Habe ich eine einfache Unity-Projekt mit zwei editor-Assistenten, die zeigen, wie man richtig nutzen Sie den C# - code oder die shader, die oben gezeigt. Holen Sie es hier:
https://github.com/Mapiarz/CubemapToEquirectangular

Denken Sie daran, die richtige import-Einstellungen in der Einheit für Ihre Eingabe Bilder:

• Punkt filtern
• Truecolor-format
• Deaktivieren mipmaps
• Nicht die Macht der 2: Keine (nur für 2DTextures)
• Aktivieren, Lesen/Schreiben (nur für 2DTextures)