ModelToImage.cpp

Go to the documentation of this file.

 
/*
 * ModelToImage.cpp
 *
 *  Created on: Jan 25, 2017
 *      Author: Thomas Wiemann (twiemann@uos.de)
 */
 
#include "lvr2/reconstruction/ModelToImage.hpp"
#include "lvr2/reconstruction/Projection.hpp"
#include "lvr2/io/Progress.hpp"
#include "lvr2/io/Timestamp.hpp"
#include "lvr2/geometry/BaseVector.hpp"
 
#include <iostream>
#include <fstream>
#include <algorithm>
#include <list>
using namespace std;
 
namespace lvr2
{
 
using Vec = BaseVector<float>;
 
ModelToImage::ModelToImage(
        PointBufferPtr buffer,
        ModelToImage::ProjectionType projection,
        int width, int height,
        float minZ, float maxZ,
        int minHorizontenAngle, int maxHorizontalAngle,
        int minVerticalAngle, int maxVerticalAngle,
        bool imageOptimization,
        CoordinateSystem system)
{
 
    // Initialize global members
    m_width = width;
    m_height = height;
    m_coordinateSystem = system;
    m_minZ = minZ;
    m_maxZ = maxZ;
    m_minHAngle = minHorizontenAngle;
    m_maxHAngle = maxHorizontalAngle;
    m_minVAngle = minVerticalAngle;
    m_maxVAngle = maxVerticalAngle;
    m_points = buffer;
 
    // Create the projection representation
    m_projection = new EquirectangularProjection(
                m_width, m_height,
                minHorizontenAngle, maxHorizontalAngle,
                minVerticalAngle, maxVerticalAngle,
                imageOptimization, system);
 
}
 
 
 
ModelToImage::~ModelToImage()
{
    // TODO Auto-generated destructor stub
}
 
void ModelToImage::computeDepthListMatrix(DepthListMatrix& mat)
{
    cout << timestamp << "Initializting DepthListMatrix with dimensions " << m_width << " x " << m_height << endl;
    // Set correct image width and height
    for(int i = 0; i < m_height; i++)
    {
        mat.pixels.emplace_back(vector<vector<PanoramaPoint> >());
        for(int j = 0; j < m_width; j++)
        {
            mat.pixels[i].push_back(vector<PanoramaPoint>());
        }
    }
 
    // Get point array and size from buffer
    size_t n_points = m_points->numPoints();
    floatArr points = m_points->getPointArray();
 
    // Create progress output
    string comment = timestamp.getElapsedTime() + "Projecting points ";
    ProgressBar progress(n_points, comment);
 
    float range;
    int img_x, img_y;
    for(int i = 0; i < n_points; i++)
    {        
        Vec ppt(points[3 * i], points[3 * i + 1], points[3 * i + 2]);
 
        m_projection->project(
                    img_x, img_y, range,
                    ppt.x, ppt.y, ppt.z);
 
        // Update min and max ranges
        if(range > mat.maxRange)
        {
            mat.maxRange = range;
        }
 
        if(range < mat.minRange)
        {
            mat.minRange = range;
        }
 
        if(range < m_maxZ)
        {
            // Add point index to image pixel
            mat.pixels[img_y][img_x].emplace_back(PanoramaPoint(i));
        }
        ++progress;
    }
    cout << endl;
}
 
void ModelToImage::computeDepthImage(ModelToImage::DepthImage& img, ModelToImage::ProjectionPolicy policy)
{
    cout << timestamp << "Computing depth image. Image dimensions: " << m_width << " x " << m_height << endl;
 
    // Set correct image width and height
    for(int i = 0; i < m_height; i++)
    {
        img.pixels.emplace_back(vector<float>());
        for(int j = 0; j < m_width; j++)
        {
            img.pixels[i].push_back(0.0f);
        }
    }
 
 
    // Get point array and size from buffer
    size_t n_points = m_points->numPoints();
    floatArr points = m_points->getPointArray();
 
    // Create progress output
    string comment = timestamp.getElapsedTime() + "Projecting points ";
    ProgressBar progress(n_points, comment);
 
    float range;
    int img_x, img_y;
    for(int i = 0; i < n_points; i++)
    {
        m_projection->project(
                    img_x, img_y, range,
                    points[3 * i], points[3 * i + 1], points[3 * i + 2]);
 
        // Update min and max ranges
        if(range > img.maxRange)
        {
            img.maxRange = range;
        }
 
        if(range < img.minRange)
        {
            img.minRange = range;
        }
 
        img.pixels[img_y][img_x] = range;
        ++progress;
    }
    cout << endl;
    cout << timestamp << "Min / Max range: " << img.minRange << " / " << img.maxRange << endl;
}
 
void ModelToImage::writePGM(string filename, float cutoff)
{
    // Compute panorama image
    ModelToImage::DepthImage img;
    computeDepthImage(img);
 
    // Clamp range values
    float min_r = std::min(m_minZ, img.minRange);
    float max_r = std::min(m_maxZ, img.maxRange);
    float interval = max_r - min_r;
 
    cout << min_r << " " << max_r << " " << interval << endl;
 
    // Open file, write header and pixel values
    std::ofstream out(filename);
    out << "P2" << endl;
    out << img.pixels[0].size() << " " << img.pixels.size() << " 255" << endl;
 
    for(int i = 0; i < img.pixels.size(); i++)
    {
        for(int j = 0; j < img.pixels[i].size(); j++)
        {
            int val = img.pixels[i][j];
 
            // Image was initialized with zeros. Fix that to
            // the measured min value
            if(val < min_r)
            {
                val = min_r;
            }
 
            val = (int)((float)(val - min_r) / interval * 255);
            out << val << " ";
        }
    }
}
 
} /* namespace lvr */