Wie wandelt sphärische Koordinaten zu equirectangular Projektion Koordinaten?

Wenn die Fotos stammen von einem festen Punkt und kann die Kamera nur drehen der yaw-und pitch-um diesen Punkt. Dann können wir betrachten eine Kugel mit einem radius (für die Mathematik ist, ist es äußerst empfehlenswert, mit einem radius von 1). Das Foto wird eine rechteckige Form auf dieser Sphäre (aus Sicht der Kamera).

Horizon-Fall

Wenn Sie auf der Suche am Horizont (äquator), dann die vertikalen Pixel Konto für breiten-und horizontal-Pixel-Konto für die Länge. Für eine einfache panorama-Foto der Horizont da ist nicht viel von einem problem:

Hier schauen wir uns grob den Horizont unserer Welt. Das heißt, die Kamera hat Winkel va = ~0. Dann ist dies ziemlich einfach, denn wenn wir wissen, dass das Foto ist 70 Grad breit und 40 Grad hoch, dann wissen wir auch, dass die Längen-Bereich werden etwa 70 Grad und einer Breite zwischen 40 Grad.

Wenn wir kümmern uns nicht um eine leichte Verzerrung, dann die Formel zur Berechnung der (longitude,latitude) aus jedem pixel (x,y) aus dem Foto wäre ganz einfach:

photo_width_deg = 70
photo_height_deg = 30
photo_width_px = 1280
photo_height_px = 720
ha = 0
va = 0
longitude = photo_width_deg * (x - photo_width_px/2) /photo_width_px + ha
latitude = photo_height_deg * (y - photo_height_px/2) /photo_height_px + va

Problem

Aber diese Annäherung arbeitet nicht auf allen, wenn wir die Kamera bewegen, viel mehr vertikal:

So, wie wir transformieren ein pixel aus dem Bild auf (x, y) zu einem (longitude, latitude) koordinieren Sie in einem gegebenen vertikalen und/oder horizontalen Winkel, in dem das Foto aufgenommen wurde (va,ha)?

Lösung

Die wichtige Idee, dass das problem bei mir gelöst, ist dies: Sie haben im Grunde beiden Sphären:

• Die photo-sphere mit der Kamera in der Mitte.
• Die geo-sphere (equirectangular Projektion einer Kugel), mit Längengrad/Breitengrad-Koordinaten.

Wissen Sie, die sphärische Koordinate eines Punkts auf dem Foto-Bereich, und Sie wollen wissen, wo dieser Punkt liegt auf der geo-Sphäre mit den verschiedenen Kamera-Winkel.

Das eigentliche problem

Müssen wir erkennen, dass es schwierig zu tun, die keine Berechnungen zwischen den beiden Sphären mit nur sphärische Koordinaten. Die Mathematik für die kartesischen Koordinatensystem ist viel einfacher. Im kartesischen Koordinatensystem können wir leicht drehen, um eine beliebige Achse mit Drehung Matrizen, dass multipliziert mit der Koordinate Vektor [x,y,z] um das gedrehte Koordinatensystem zurück.

Warnung: Hier ist es sehr wichtig zu wissen, dass es gibt verschiedene Konventionen im Hinblick auf die Bedeutung der x-Achse y-Achse, und z-Achse. Es ist ungewiss, welche Achse ist die vertikale und die Punkte wo. Sie müssen nur eine Zeichnung für sich selbst und entscheiden Sie sich für diese. Wenn das Ergebnis falsch ist, ist es wahrscheinlich, weil diese gemischt sind. Das gleiche gilt für die theta und phi für sphärische Koordinaten.

Die wirkliche Lösung

So der trick ist die Verwandlung von Foto-Bereich zu Kartesisch, dann gelten die Drehungen, und dann gehen Sie zurück zu sphärischen Koordinaten:

1. Nehmen jedes pixels auf dem Foto, und berechnen Sie den relativen Grad ist es Weg von der Mitte des Bildes sowohl horizontal als auch vertikal.
2. Verwandeln die photo-sphere sphärischen Koordinaten in kartesische Koordinaten ([x,y,z] Vektoren).
3. Gelten rotation Matrizen auf die Koordinate genau wie die Kamera gedreht wurde (ha,va).
4. Transformieren die kartesischen Koordinaten zurück in sphärischen Koordinaten, und diese werden nach Ihren Längen-und Breitengrad.

Beispiel-code

//Photo resolution
double img_w_px = 1280;
double img_h_px = 720;
//Camera field-of-view angles
double img_ha_deg = 70;
double img_va_deg = 40;
//Camera rotation angles
double hcam_deg = 230;
double vcam_deg = 60;
//Camera rotation angles in radians
double hcam_rad = hcam_deg/180.0*PI;
double vcam_rad = vcam_rad/180.0*PI;
//Rotation around y-axis for vertical rotation of camera
Matrix rot_y = {
    cos(vcam_rad), 0, sin(vcam_rad),
    0, 1, 0,
    -sin(vcam_rad), 0, cos(vcam_rad)
};
//Rotation around z-axis for horizontal rotation of camera
Matrix rot_z = {
    cos(hcam_rad), -sin(hcam_rad), 0,
    sin(hcam_rad), cos(hcam_rad), 0,
    0, 0, 1
};

Image img = load('something.png');
for(int i=0;i<img_h_px;++i)
{
    for(int j=0;j<img_w_px;++j)
    {
        Pixel p = img.getPixelAt(i, j);

        //Calculate relative position to center in degrees
        double p_theta = (j - img_w_px /2.0) /img_w_px * img_w_deg /180.0 * PI;
        double p_phi = -(i - img_h_px /2.0) /img_h_px * img_h_deg /180.0 * PI;

        //Transform into cartesian coordinates
        double p_x = cos(p_phi) * cos(p_theta);
        double p_y = cos(p_phi) * sin(p_theta);
        double p_z = sin(p_phi);
        Vector p0 = {p_x, p_y, p_z};

        //Apply rotation matrices (note, z-axis is the vertical one)
        //First vertically
        Vector p1 = rot_y * p0;
        Vector p2 = rot_z * p1;

        //Transform back into spherical coordinates
        double theta = atan2(p2[1], p2[0]);
        double phi = asin(p2[2]);

        //Retrieve longitude,latitude
        double longitude = theta /PI * 180.0;
        double latitude = phi /PI * 180.0;

        //Now we can use longitude,latitude coordinates in many different projections, such as:
        //Polar projection
        {
            int polar_x_px = (0.5*PI + phi)*0.5 * cos(theta) /PI*180.0 * polar_w;
            int polar_y_px = (0.5*PI + phi)*0.5 * sin(theta) /PI*180.0 * polar_h;
            polar.setPixel(polar_x_px, polar_y_px, p.getRGB());
        }
        //Geographical (=equirectangular) projection
        {
            int geo_x_px = (longitude + 180) * geo_w;
            int geo_y_px = (latitude + 90) * geo_h;
            geo.setPixel(geo_x_px, geo_y_px, p.getRGB());
        }
        //...
    }
}

Beachten Sie, dies ist nur eine Art von pseudo-code. Es wird empfohlen, um eine matrix-Bibliothek, die mit Ihren Multiplikationen und Rotationen von Matrizen und Vektoren.