StvFile.cpp

Go to the documentation of this file.

#include "StvFile.h"
#include <fstream.h>

static std::vector< double > getNumbersInLine (char *line)
{
    std::vector< double > rtn;
    double curNumber;
    char separators[] = " ][\t";
    char *token = strtok (line, separators);
    while (token != NULL)
    {
        if (1 == sscanf (token, "%lf", &curNumber))
            rtn.push_back (curNumber);
        token = strtok (NULL, separators);
    }

    return rtn;
}

static void eraseFirstToken (std::string &s)
{
    // erase leading spaces
    while (s.size() && isspace(s[0]))
        s.erase (0,1);
    // erase leading spaces
    while (s.size() && !isspace(s[0]))
        s.erase (0,1);
    // erase leading spaces
    while (s.size() && isspace(s[0]))
        s.erase (0,1);
}

static void removeSurroundingSpaces (std::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);
}

StvFile::StvFile (const char *filename, Viewpoint &photo) : img(photo) 
{
    ifstream stvFile (filename);
    if (stvFile.fail())
        throw RuntimeError ("Unable to open file: %s", filename);
    
/*
 * Get numbers from stv file
 */
    std::vector< double > center_of_projection_numbers;
    std::vector< double > projection_matrix_numbers;
    
    char stvLine[512];
    while (stvFile.getline (stvLine, sizeof(stvLine)))
    {
        if (stvLine == strstr(stvLine, "center_of_projection"))
            center_of_projection_numbers = getNumbersInLine (stvLine);
        else if (stvLine == strstr(stvLine, "projection_matrix"))
            projection_matrix_numbers = getNumbersInLine (stvLine);  
        else if (stvLine == strstr(stvLine, "silhouette"))
            silhouette_filename = stvLine;
        else if (stvLine == strstr(stvLine, "texture"))
            photo_filename = stvLine;
    }
    
/*
 * Clean up and verify that we read in the right amount of data
 */
    eraseFirstToken (silhouette_filename);
    eraseFirstToken (photo_filename);
    removeSurroundingSpaces (silhouette_filename);
    removeSurroundingSpaces (photo_filename);
    
    bool bDisableSilhouettes = false;
    if (!silhouette_filename.size())
        bDisableSilhouettes = true;

    img.loadFromFiles (photo_filename.c_str(), !bDisableSilhouettes?silhouette_filename.c_str():NULL);
    
    if (center_of_projection_numbers.size() != 3)
        throw RuntimeError ("Bad/missing center_of_projection in %s", filename);
    if (projection_matrix_numbers.size() != 9)
        throw RuntimeError ("Bad/missing projection matrix in %s", filename);
    if (photo_filename.size() < 1)
        throw RuntimeError ("Bad/missing texture filename in %s.", filename); 
    
    Matrix<3, 3, double> projMatrix;
    memcpy (&projMatrix[0], &projection_matrix_numbers[0], sizeof(double)*9);
    projMatrix = projMatrix.getTranspose();
    
/*
 * Put them into our member variables
 */
    // get numbers from projection matrix
    memcpy (&du[0], &projMatrix(0,0), sizeof(double)*3);
    memcpy (&dv[0], &projMatrix(1,0), sizeof(double)*3);
    memcpy (&cop_to_origin_vector[0], &projMatrix(2,0), sizeof(double)*3);
    
    // get COP
    memcpy (&center_of_projection[0], &center_of_projection_numbers[0], sizeof(double)*3);
    
    origin_of_projection = center_of_projection + cop_to_origin_vector;
}

void StvFile::print() const
{
    MTRACE ("******** StvData %s Printing **********", photo_filename.c_str());
    center_of_projection.print("center_of_projection");
    du.print("du");
    dv.print("dv");
    cop_to_origin_vector.print("cop_to_origin_vector");
}

double StvFile::calculateWidthOverHeight() const
{
    // calculate aspect ratio
    double imageWidth = img.getWidth() * du.getLength();
    double imageHeight = img.getHeight() * dv.getLength();
    return (double)imageWidth / imageHeight;
}


  Vertex StvFile::calculateLookatPoint() const
{
    Vertex projection_plane_center;
    ColVector3 cop_to_center, cop_to_worldspace_origin;
    double dist_to_worldspace_origin;

    projection_plane_center = 
        origin_of_projection + 
        du * (double)img.getWidth()/2 + 
        dv * (double)img.getHeight()/2;

    cop_to_worldspace_origin = Vertex(0,0,0) - center_of_projection;
    dist_to_worldspace_origin = cop_to_worldspace_origin.getLength();
    
    cop_to_center = projection_plane_center - center_of_projection;
    cop_to_center.normalize();
    cop_to_center = cop_to_center * dist_to_worldspace_origin;

    return (center_of_projection + cop_to_center);
}

ColVector3 StvFile::calculateUpVector() const
{
    ColVector3 upVector = dv * -1.;
    upVector.normalize();
    return upVector;
}

double StvFile::calculateVerticalFOV() const
{
    Vertex middle_top =
        origin_of_projection + 
        (du * (double)img.getWidth() / 2.);

    Vertex middle_bottom = 
        middle_top +
        (dv * (double)img.getHeight());

    ColVector3 cop_to_top = middle_top - center_of_projection; 
    ColVector3 cop_to_bottom = middle_bottom - center_of_projection;
    cop_to_top.normalize();
    cop_to_bottom.normalize();

    double cos_vertical_fov = cop_to_top.dotProduct(cop_to_bottom);
   // Message ("vert is %.2lf", 180. * acos(cos_vertical_fov) / M_PI);
    return (180. * acos(cos_vertical_fov) / M_PI);
}

Vertex StvFile::getCenterOfProjection () const
{ return center_of_projection; }

---