Convertir 2:1 équirectangulaire panorama de cube map

J'ai écrit un script pour couper le générés cubemap dans des fichiers individuels (posx.png, negx.png, posy.png, negy.png, posz.png et negz.png). Il sera également le pack de 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 de l'image:

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

Les fichiers convertis sont:

Voici un (naïvement) version modifiée de Salix Alba est absolument fantastique répondre qui convertit une face à la fois, crache de six images différentes, et conserve l'image d'origine du type de fichier.

Mis à part le fait la plupart des cas d'utilisation probablement s'attendre six images distinctes, le principal avantage de la conversion d'un visage à un moment, c'est qu'il vous permet de travailler avec des images énormes beaucoup moins gourmande en 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])

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

Le code fourni peut en toute sécurité être utilisé dans un site web travailleur, 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) {...}

Très simple, C++ application qui convertit une projection équirectangulaire panorama de cube map en fonction de la réponse par Salix Alba => https://github.com/denivip/panorama

Peut-être que je suis absent quelque chose ici. Mais il semble que la plupart, si pas tous les transformation de code peut être quelque peu incorrect. Ils prennent un panorama sphérique (équirectangulaire --- 360 ° horizontalement et 180 ° verticalement) et semblent convertir les faces du cube à l'aide d'un cartésien <-> cylindrique de transformation. Ne devraient-ils pas être l'aide d'un cartésien <-> sphérique de transformation. Voir http://mathworld.wolfram.com/SphericalCoordinates.html

Je suppose que tant qu'ils inverser le calcul d'aller de l'faces du cube pour le panorama, alors il devrait fonctionner. Mais les images des faces du cube peut être légèrement différent lors de l'utilisation de la partie sphérique de la transformation.

Si je commence avec cette dernière (panorama sphérique):

Alors si j'utilise un cylindrique de transformation (dont je ne suis pas sûr à 100% est correct en ce moment), j'obtiens ce résultat:

Mais si j'utilise une sphère de transformation, j'obtiens ce résultat:

Ils ne sont pas les mêmes. Mais mon sphérique résultat de transformation semble correspondre à la suite de Merci Xif au catalogue, mais son lien ne montre pas le genre de transformation, il est de l'aide, du mieux que je peux lire.

Je suis malentendu le code utilisé par de nombreux contributeurs à ce sujet?