Conversion 2: 1 panorama équirectangulaire en Carte cube

étant donné l'excellente réponse acceptée, je voulais ajouter mon correspondant C++ implementation , basé sur OpenCV .

pour ceux qui ne connaissent pas OpenCV, pensez à Mat comme une image. Nous construisons d'abord deux cartes qui se refont de l'image équirectangulaire à notre Face cubemap correspondante. Ensuite, nous effectuons le levage lourd (i.e. remapping avec interpolation) en utilisant OpenCV.

le code peut être rendue plus compacte, si la lisibilité n'est pas une préoccupation.

// Define our six cube faces. 
// 0 - 3 are side faces, clockwise order
// 4 and 5 are top and bottom, respectively
float faceTransform[6][2] = 
{ 
    {0, 0},
    {M_PI / 2, 0},
    {M_PI, 0},
    {-M_PI / 2, 0},
    {0, -M_PI / 2},
    {0, M_PI / 2}
};

// Map a part of the equirectangular panorama (in) to a cube face
// (face). The ID of the face is given by faceId. The desired
// width and height are given by width and height. 
inline void createCubeMapFace(const Mat &in, Mat &face, 
        int faceId = 0, const int width = -1, 
        const int height = -1) {

    float inWidth = in.cols;
    float inHeight = in.rows;

    // Allocate map
    Mat mapx(height, width, CV_32F);
    Mat mapy(height, width, CV_32F);

    // Calculate adjacent (ak) and opposite (an) of the
    // triangle that is spanned from the sphere center 
    //to our cube face.
    const float an = sin(M_PI / 4);
    const float ak = cos(M_PI / 4);

    const float ftu = faceTransform[faceId][0];
    const float ftv = faceTransform[faceId][1];

    // For each point in the target image, 
    // calculate the corresponding source coordinates. 
    for(int y = 0; y < height; y++) {
        for(int x = 0; x < width; x++) {

            // Map face pixel coordinates to [-1, 1] on plane
            float nx = (float)y / (float)height - 0.5f;
            float ny = (float)x / (float)width - 0.5f;

            nx *= 2;
            ny *= 2;

            // Map [-1, 1] plane coords to [-an, an]
            // thats the coordinates in respect to a unit sphere 
            // that contains our box. 
            nx *= an; 
            ny *= an; 

            float u, v;

            // Project from plane to sphere surface.
            if(ftv == 0) {
                // Center faces
                u = atan2(nx, ak);
                v = atan2(ny * cos(u), ak);
                u += ftu; 
            } else if(ftv > 0) { 
                // Bottom face 
                float d = sqrt(nx * nx + ny * ny);
                v = M_PI / 2 - atan2(d, ak);
                u = atan2(ny, nx);
            } else {
                // Top face
                float d = sqrt(nx * nx + ny * ny);
                v = -M_PI / 2 + atan2(d, ak);
                u = atan2(-ny, nx);
            }

            // Map from angular coordinates to [-1, 1], respectively.
            u = u / (M_PI); 
            v = v / (M_PI / 2);

            // Warp around, if our coordinates are out of bounds. 
            while (v < -1) {
                v += 2;
                u += 1;
            } 
            while (v > 1) {
                v -= 2;
                u += 1;
            } 

            while(u < -1) {
                u += 2;
            }
            while(u > 1) {
                u -= 2;
            }

            // Map from [-1, 1] to in texture space
            u = u / 2.0f + 0.5f;
            v = v / 2.0f + 0.5f;

            u = u * (inWidth - 1);
            v = v * (inHeight - 1);

            // Save the result for this pixel in map
            mapx.at<float>(x, y) = u;
            mapy.at<float>(x, y) = v; 
        }
    }

    // Recreate output image if it has wrong size or type. 
    if(face.cols != width || face.rows != height || 
        face.type() != in.type()) {
        face = Mat(width, height, in.type());
    }

    // Do actual resampling using OpenCV's remap
    remap(in, face, mapx, mapy, 
         CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0));
}

étant donné l'entrée suivante:

les faces suivantes sont générées:

image courtoisie de Optonaut .

j'ai écrit un script pour couper le cubemap généré en fichiers individuels (posx.png, negx.png, posy.png, négy.png, posz.png et negz.png). Il va aussi empaqueter les 6 fichiers dans un .fichier zip.

la source est ici: https://github.com/dankex/compv/blob/master/3d-graphics/skybox/cubemap-cut.py

vous pouvez modifier le tableau pour définir les fichiers image:

name_map = [ \
 ["", "", "posy", ""],
 ["negz", "negx", "posz", "posx"],
 ["", "", "negy", ""]]

Les fichiers convertis sont:

Voici une version (naïvement) modifiée de la réponse absolument fantastique de Salix Alba qui convertit un visage à la fois, crache six images différentes et préserve le type de fichier de l'image originale.

mis à part le fait que la plupart des cas d'utilisation attendent probablement six images séparées, le principal avantage de convertir un visage à la fois est qu'il rend le travail avec des images énormes beaucoup moins intensif de mémoire.

#!/usr/bin/env python
import sys
from PIL import Image
from math import pi, sin, cos, tan, atan2, hypot, floor
from numpy import clip

# get x,y,z coords from out image pixels coords
# i,j are pixel coords
# faceIdx is face number
# faceSize is edge length
def outImgToXYZ(i, j, faceIdx, faceSize):
    a = 2.0 * float(i) / faceSize
    b = 2.0 * float(j) / faceSize

    if faceIdx == 0: # back
        (x,y,z) = (-1.0, 1.0 - a, 1.0 - b)
    elif faceIdx == 1: # left
        (x,y,z) = (a - 1.0, -1.0, 1.0 - b)
    elif faceIdx == 2: # front
        (x,y,z) = (1.0, a - 1.0, 1.0 - b)
    elif faceIdx == 3: # right
        (x,y,z) = (1.0 - a, 1.0, 1.0 - b)
    elif faceIdx == 4: # top
        (x,y,z) = (b - 1.0, a - 1.0, 1.0)
    elif faceIdx == 5: # bottom
        (x,y,z) = (1.0 - b, a - 1.0, -1.0)

    return (x, y, z)

# convert using an inverse transformation
def convertFace(imgIn, imgOut, faceIdx):
    inSize = imgIn.size
    outSize = imgOut.size
    inPix = imgIn.load()
    outPix = imgOut.load()
    faceSize = outSize[0]

    for xOut in xrange(faceSize):
        for yOut in xrange(faceSize):
            (x,y,z) = outImgToXYZ(xOut, yOut, faceIdx, faceSize)
            theta = atan2(y,x) # range -pi to pi
            r = hypot(x,y)
            phi = atan2(z,r) # range -pi/2 to pi/2

            # source img coords
            uf = 0.5 * inSize[0] * (theta + pi) / pi
            vf = 0.5 * inSize[0] * (pi/2 - phi) / pi

            # Use bilinear interpolation between the four surrounding pixels
            ui = floor(uf)  # coord of pixel to bottom left
            vi = floor(vf)
            u2 = ui+1       # coords of pixel to top right
            v2 = vi+1
            mu = uf-ui      # fraction of way across pixel
            nu = vf-vi

            # Pixel values of four corners
            A = inPix[ui % inSize[0], clip(vi, 0, inSize[1]-1)]
            B = inPix[u2 % inSize[0], clip(vi, 0, inSize[1]-1)]
            C = inPix[ui % inSize[0], clip(v2, 0, inSize[1]-1)]
            D = inPix[u2 % inSize[0], clip(v2, 0, inSize[1]-1)]

            # interpolate
            (r,g,b) = (
              A[0]*(1-mu)*(1-nu) + B[0]*(mu)*(1-nu) + C[0]*(1-mu)*nu+D[0]*mu*nu,
              A[1]*(1-mu)*(1-nu) + B[1]*(mu)*(1-nu) + C[1]*(1-mu)*nu+D[1]*mu*nu,
              A[2]*(1-mu)*(1-nu) + B[2]*(mu)*(1-nu) + C[2]*(1-mu)*nu+D[2]*mu*nu )

            outPix[xOut, yOut] = (int(round(r)), int(round(g)), int(round(b)))

imgIn = Image.open(sys.argv[1])
inSize = imgIn.size
faceSize = inSize[0] / 4
components = sys.argv[1].rsplit('.', 2)

FACE_NAMES = {
  0: 'back',
  1: 'left',
  2: 'front',
  3: 'right',
  4: 'top',
  5: 'bottom'
}

for face in xrange(6):
  imgOut = Image.new("RGB", (faceSize, faceSize), "black")
  convertFace(imgIn, imgOut, face)
  imgOut.save(components[0] + "_" + FACE_NAMES[face] + "." + components[1])

a trouvé cette question, et même si les réponses sont bonnes, je pense qu'il y a encore du terrain découvert, donc voici mes deux cents.

D'abord: sauf si vous devez vraiment convertir les images vous-même (c.-à-d. en raison d'une exigence de logiciel spécifique), ne pas .

la raison est que, même s'il ya une cartographie très simple entre la projection équirectangulaire et la projection cubique, la cartographie entre les zones n'est pas simple : lorsque vous établissez une correspondance entre un point spécifique de votre image de destination et un point dans la source avec un calcul élémentaire, dès que vous convertissez les deux points en pixels en arrondissant vous faites un très approximation brute qui ne tient pas compte de la taille des pixels, et la qualité de l'image est liée à être faible.

Deuxièmement: même si vous avez besoin de faire le de conversion au moment de l'exécution, êtes-vous sûr que vous avez besoin de faire la conversion? À moins qu'il n'y ait un problème de performance très strict, si vous avez juste besoin d'une skybox, créer une très grande sphère, piquer le texure équirectangulaire sur elle, et vous partez. Trois JS fournit la sphère déjà, comme je me souviens bien ;-)

Troisièmement: la NASA fournit un outil pour convertir entre toutes les projections imaginables (je viens de le découvrir, je l'ai testé, et fonctionne comme un charme). Vous pouvez le trouver ici:

G. Projector-Global Map Projector

et je trouve raisonnable de penser que les gars savent ce qu'ils font ;-)

Espérons que cette aide

UPDATE: il s'avère que les " guys " savent ce qu'ils font jusqu'à un certain point: le cubemap généré a une bordure hideuse qui rend la conversion pas si facile...

mise à jour 2: trouvé l'outil définitif pour equirectangular à la conversion cubemap, et il est appelé erect2cubic .

c'est un petit utilitaire qui génère un script à transmettre à hugin, de cette façon:

$ erect2cubic --erect=input.png --ptofile=cube.pto
$ nona -o cube_prefix cube.pto 

(information siphonnée de Vinay's Hacks page)

et générera les 6 faces cubemap. Je l'utilise pour mon projet et il fonctionne comme un charme !

le seul inconvénient de cette approche est que le script erect2cubit ce n'est pas dans la distribution Ubuntu standard (qui est ce que j'utilise) et j'ai dû recourir aux instructions à ce lien:

Blog décrivant comment installer et utiliser erect2cubic

pour savoir comment l'installer.

ça vaut le coup!

cmft Studio supports conversion/filtering de diverses HDR/LDR projections à cubemaps .

https://github.com/dariomanesku/cmftStudio

il existe diverses représentations de cartes d'environnement. Voici un bel aperçu.

Vue D'Ensemble-Images Panoramiques

si vous utilisez Photosphere (ou n'importe quelle application de panorama), vous avez probablement déjà la représentation horizontale latitude / longitude . Vous pouvez alors simplement dessiner un trois texturé.js SphereGeometry . Voici un tutoriel sur la façon de rendre terre.

Tutoriel - Comment faire la terre dans WebGL?

bonne chance :).

une application C++ très simple qui convertit un panorama équirectangulaire en Carte cube basée sur la réponse de Salix Alba = > https://github.com/denivip/panorama

Voici une version JavaScript du code de Benjamn Dobell. Le convertFace doit être passé deux ìmageData objets et un visage ID (0-6).

le code fourni peut être utilisé en toute sécurité dans un travailleur web, car il n'a pas de dépendances.

        // convert using an inverse transformation
        function convertFace(imgIn, imgOut, faceIdx) {
            var inPix = shimImgData(imgIn),
                        outPix = shimImgData(imgOut),
                        faceSize = imgOut.width,
                        pi = Math.PI,
                        pi_2 = pi/2;

            for(var xOut=0;xOut<faceSize;xOut++) {
                    for(var yOut=0;yOut<faceSize;yOut++) {

                    var xyz = outImgToXYZ(xOut, yOut, faceIdx, faceSize);
                    var theta = Math.atan2(xyz.y, xyz.x); // range -pi to pi
                    var r = Math.hypot(xyz.x,xyz.y);
                    var phi = Math.atan2(xyz.z,r); // range -pi/2 to pi/2

                    // source img coords
                    var uf = 0.5 * imgIn.width * (theta + pi) / pi;
                    var vf = 0.5 * imgIn.width * (pi_2 - phi) / pi;

                    // Use bilinear interpolation between the four surrounding pixels
                    var ui = Math.floor(uf);  // coord of pixel to bottom left
                    var vi = Math.floor(vf);
                    var u2 = ui+1;       // coords of pixel to top right
                    var v2 = vi+1;
                    var mu = uf-ui;      // fraction of way across pixel
                    var nu = vf-vi;

                    // Pixel values of four corners
                    var A = inPix.getPx(ui % imgIn.width, clip(vi, 0, imgIn.height-1));
                    var B = inPix.getPx(u2 % imgIn.width, clip(vi, 0, imgIn.height-1));
                    var C = inPix.getPx(ui % imgIn.width, clip(v2, 0, imgIn.height-1));
                    var D = inPix.getPx(u2 % imgIn.width, clip(v2, 0, imgIn.height-1));

                    // interpolate
                    var rgb = {
                      r:A[0]*(1-mu)*(1-nu) + B[0]*(mu)*(1-nu) + C[0]*(1-mu)*nu+D[0]*mu*nu,
                      g:A[1]*(1-mu)*(1-nu) + B[1]*(mu)*(1-nu) + C[1]*(1-mu)*nu+D[1]*mu*nu,
                      b:A[2]*(1-mu)*(1-nu) + B[2]*(mu)*(1-nu) + C[2]*(1-mu)*nu+D[2]*mu*nu
                    };

                    rgb.r=Math.round(rgb.r);
                    rgb.g=Math.round(rgb.g);
                    rgb.b=Math.round(rgb.b);

                    outPix.setPx(xOut, yOut, rgb);

                } // for(var yOut=0;yOut<faceSize;yOut++) {...}
             } // for(var xOut=0;xOut<faceSize;xOut++) {...}
        } // function convertFace(imgIn, imgOut, faceIdx) {...}

        // get x,y,z coords from out image pixels coords
        // i,j are pixel coords
        // faceIdx is face number
        // faceSize is edge length
        function outImgToXYZ(i, j, faceIdx, faceSize) {
            var a = 2 * i / faceSize,
                    b = 2 * j / faceSize;

            switch(faceIdx) {
                case 0: // back
                return({x:-1, y:1-a, z:1-b});
            case 1: // left
                return({x:a-1, y:-1, z:1-b});
            case 2: // front
                return({x: 1, y:a-1, z:1-b});
            case 3: // right
                return({x:1-a, y:1, z:1-b});
            case 4: // top
                return({x:b-1, y:a-1, z:1});
            case 5: // bottom
                return({x:1-b, y:a-1, z:-1});

            }
        } // function outImgToXYZ(i, j, faceIdx, faceSize) {...}

        function clip(val, min, max) {
            return(val<min?min:(val>max?max:val));
        }

        function shimImgData(imgData) {
            var w=imgData.width*4,
                    d=imgData.data;

            return({
                getPx:function(x,y) {
                    x=x*4+y*w;
                    return([ d[x], d[x+1], d[x+2] ]);
                },
                setPx:function(x,y,rgb) {
                    x=x*4+y*w;
                    d[x]=rgb.r;
                    d[x+1]=rgb.g;
                    d[x+2]=rgb.b;
                    d[x+3]=255; // alpha
                }
            });
        } // function shimImgData(imgData) {...}

j'ai créé une solution pour ce problème en utilisant OpenGL et j'ai créé un outil en ligne de commande autour de celui-ci. Il fonctionne à la fois avec des images et des vidéos, et c'est l'outil le plus rapide que j'ai trouvé là-bas.

Convert360 - projet sur GitHub.

OpenGL Shader - le fragment shader utilisé pour la re-projection.

l'usage est aussi simple que:

$ pip install convert360
$ convert360 -i ~/Pictures/Barcelona/sagrada-familia.jpg -o example.png -s 300 300

pour obtenir quelque chose comme ceci:

peut-être que je manque quelque chose ici. Mais il semble que la plupart sinon la totalité du code de transformation présenté peut être quelque peu incorrect. Ils prennent un panorama sphérique (equirectangular - - 360 degrés horizontalement et 180 degrés verticalement) et semblent se convertir aux faces du cube en utilisant une transformation cartésienne <-> cylindrique. S'ils n'utilisent pas une transformation cartésienne <-> sphérique. Voir http://mathworld.wolfram.com/SphericalCoordinates.html

je suppose que tant qu'ils inversent le calcul pour passer des faces du cube au panorama, alors il devrait fonctionner. Mais les images des faces du cube peuvent être légèrement différentes en utilisant la transformation sphérique.

si je commence par ce equirectangular (panorama sphérique):

puis si j'utilise une transformation cylindrique (que je ne suis pas sûr à 100% est correct à ce moment-là), je reçois ce résultat:

mais si j'utilise une transformation sphérique, j'obtiens ce résultat:

Ils ne sont pas les mêmes. Mais mon résultat de transformation sphérique semble correspondre au résultat de Danke Xie, mais son lien ne montre pas le genre de transformation qu'il utilise, comme le meilleur que je puisse lire.

est-ce que je me méprends sur le code utilisé par de nombreux contributeurs à ce sujet?