Viewpoint.cpp

Go to the documentation of this file.

#include "../common/standard.h"
#include <windows.h>
#include <GL/glu.h>
#include <fstream.h>
#include <string>
using std::string;

#include "XmlNode.h"
#include "Viewpoint.h"
#include "StvFile.h"
#include "GLutils.h"


void Viewpoint::loadFromFiles (const char *photo_filename, const char *silhouette_filename /* can be NULL */)
{
    photo.loadFile (photo_filename);
    assert (photo.getWidth() && photo.getHeight());
    if (silhouette_filename)
    {
        silhouette.loadFile (silhouette_filename);
        bHasSilhouette = true;
    }
    else
        bHasSilhouette = false;
    
}





void Viewpoint::setExtrinsics (const ColVector3 up_vector, const Vertex center_of_projection, const Vertex lookat_point) 
{
    upVector = up_vector;
    COP = center_of_projection;
    lookatPoint = lookat_point;

    ModelviewMatrix *m = (ModelviewMatrix*)&modelview;
    m->setToIdentity();
    m->lookAt (COP, lookatPoint, upVector);
}

void Viewpoint::setIntrinsics (double vert_fov, double width_over_height, double near_plane, double far_plane) 
{
    verticalFOV     = vert_fov;
    widthOverHeight = width_over_height;
    nearPlane       = near_plane;
    farPlane        = far_plane;

    ProjectionMatrix *m = (ProjectionMatrix*)&projection;
    m->setToIdentity();
    m->setPerspective (
        verticalFOV,
        widthOverHeight,
        nearPlane,
        farPlane);
}

double* Viewpoint::getModelviewMatrix () const
{
    ModelviewMatrix *m = (ModelviewMatrix*)&modelview;
    return (&m->operator[](0));
}


double* Viewpoint::getProjectionMatrix() const
{
    ProjectionMatrix *m = (ProjectionMatrix*)&projection;
    return (&m->operator[](0));
}





void ViewpointList::loadSettingsFromXml(const char *filename)
{
    XmlNode d;
    d.loadFile(filename);
    
/*
 * Load info for each image that we have
 */
    
    XmlNodeList nodes = d.getNodes("scanner/img");
    
    if (nodes.getCount() < 1)
        throw RuntimeError ("Settings::loadFromFile(): please specify an img tag.");
    
    char *fname = strrchr (filename, '\\');
    if (!fname) 
        throw LogicError("ViewpointList::loadSettingsFromXml(): The filename must include a fully-qualified path");

    char path[512];
    memset(path, 0, sizeof(path));
    strncpy(path, filename, MIN(fname - filename, sizeof(path)-1));

    if (!SetCurrentDirectory (path))
        throw LogicError("ViewpointList::loadSettingsFromXml(): Can't set directory to %s", path);

    for (int i = 0; i < nodes.getCount(); i++)
    {
        XmlNode n = nodes.getNode(i);
        
        Viewpoint img;
        
    /* 
     * Load extrinsics
     */ 
        Vertex COP, lookatPoint;
        n.getAttrib (COP[0], "center_of_projection/@x");
        n.getAttrib (COP[1], "center_of_projection/@y");
        n.getAttrib (COP[2], "center_of_projection/@z");
        
        n.getAttrib (lookatPoint[0], "lookat_point/@x");
        n.getAttrib (lookatPoint[1], "lookat_point/@y");
        n.getAttrib (lookatPoint[2], "lookat_point/@z");
        
        ColVector3 upVector;

        // the up vector is optional, so if we can't get it,
        // we'll just set it to the y-axis.
        try 
        {
            n.getAttrib (upVector[0], "up_vector/@x");
            n.getAttrib (upVector[1], "up_vector/@y");
            n.getAttrib (upVector[2], "up_vector/@z");
        }
        catch (...)
        {
            upVector = ColVector3(0,1,0);
        }
        upVector.normalize();
        
        // finally, give our extrinsics to the image.
        img.setExtrinsics (upVector, COP, lookatPoint);
        
    /*
     * Load our camera intrinsic info
     */
        double nearPlane, verticalFOV, widthOverHeight, farPlane;
        n.getAttrib (nearPlane,       "near_plane/@value");
        n.getAttrib (verticalFOV,     "vertical_fov/@value");
        n.getAttrib (widthOverHeight, "width_over_height/@value");
        
        
        ColVector3 diff = lookatPoint - COP;
        diff = diff * 2;
        farPlane = diff.getLength();
        
        img.setIntrinsics (verticalFOV, widthOverHeight, nearPlane, farPlane);
        
        push_back(img);
        
        string filename = fmtString ("%s", n.getAttrib("@src").c_str());
        Viewpoint &lastImage = this->at(this->size()-1);

        try 
        {
            std::string s = n.getAttrib("silhouette/@value");
            char silhouette_filename[512];
            sprintf(silhouette_filename, "%s", s.c_str());
            lastImage.loadFromFiles(filename.c_str(), silhouette_filename);
        }
        catch (...)
        {   
            lastImage.loadFromFiles(filename.c_str(), NULL);
        }
    }
}


void ViewpointList::loadFromFile (const char *filename)
{
    char *ext = strrchr (filename, '.');

    if (!ext)
        throw ArgError ("loadSettings(): Your file must have an .xml or a .col extension.");

    clear();
    if (0 == _stricmp(ext, ".scn"))
        loadSettingsFromXml (filename);
    else if (0 == _stricmp(ext, ".col"))
        loadSettingsFromCol (filename);
    else 
        throw ArgError ("loadSettings(): Your file must have an .xml or a .col extension.");
}


static void removeSurroundingSpaces (string & s)
{
    // erase trailing spaces
    while (s.size() && isspace(s[s.size()-1]))
        s.resize (s.size() - 1);

    // erase leading spaces
    while (s.size() && isspace(s[0]))
        s.erase (0,1);
}

void ViewpointList::loadSettingsFromCol (const char *filename)
{
    ifstream colFile (filename);

    if (colFile.fail())
        throw RuntimeError ("Unable to open file: %s", filename);

    // get number of .stv files in this .col file.
    int numStvFiles;
    colFile >> numStvFiles;
    char stvFilename[512];
    colFile.eatwhite(); // go to next line

    // for each stv file, read in its data. One CalibratedImage is added
    // to our list for each stv file.
    for (int i = 0; i < numStvFiles; i++)
    {
        if (!colFile.getline(stvFilename, sizeof(stvFilename)))
            throw RuntimeError("Didn't find entry %d/%d in %s.", i, numStvFiles, filename);

        std::string fname_clean = stvFilename;
        removeSurroundingSpaces (fname_clean);

        Viewpoint img;
        StvFile stvData (fname_clean.c_str(), img);

        double widthOverHeight = stvData.calculateWidthOverHeight();
        double verticalFOV     = stvData.calculateVerticalFOV();
        ColVector3 up_vector   = stvData.calculateUpVector();
        Vertex lookat_point    = stvData.calculateLookatPoint();

        ColVector3 look_vector = (lookat_point - stvData.getCenterOfProjection());
        double dist_to_lookat_point = look_vector.getLength();

        // set the intrinsics and extrinsics for this image, and add it to the list
        img.setIntrinsics(verticalFOV, widthOverHeight, dist_to_lookat_point/20., dist_to_lookat_point * 2);
        img.setExtrinsics(up_vector, stvData.getCenterOfProjection(), lookat_point);

        push_back (img);
    }
}

---