a_image.cxx

Go to the documentation of this file.

/*
         Copyright 2002-2016 Pierre SMARS (smars@yuntech.edu.tw)
         This program is free software: you can redistribute it and/or modify
         it under the terms of the GNU General Public License as published by
         the Free Software Foundation, either version 2 of the License, or
         (at your option) any later version.
 
         This program is distributed in the hope that it will be useful,
         but WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
         GNU General Public License for more details.
 
         You should have received a copy of the GNU General Public License
         along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include <sstream>
#include "vtkImageData.h"
#include "vtkImageReader2.h"
#include "vtkTIFFReader.h"
#include "vtkJPEGReader.h"
#include "vtkPNGReader.h"
 
#include "a_image.h"
 
//--------------Stroustroup, p.591
//comparisons without case
int cmp_nocase(const std::string& s, const std::string& s2)
{
        std::string::const_iterator p = s.begin();
        std::string::const_iterator p2 = s2.begin();
        while (p != s.end() && p2 != s2.end())
        {
                if (toupper(*p) != toupper(*p2))
                        return (toupper(*p) < toupper(*p2)) ? -1 : 1;
                ++p;
                ++p2;
        }
        return (s2.size() == s.size()) ? 0 : (s.size() < s2.size()) ? -1 : 1; //size is unsigned
}
 
//---------------------------------------------------------------------------
a_image::a_image(const std::string & image_file, const std::string & matrix_file)
{
        name_ = "noname";
        texture_ = 0;
        p_ = 0;
        this->image(image_file);
        this->pmatrix(matrix_file);
}
//---------------------------------------------------------------------------
a_image::~a_image()
{
        texture_->Delete();
}
//---------------------------------------------------------------------------
const std::string a_image::help()
{
        std::ostringstream o;
        o << "*******" << std::endl;
        o << "a_image" << std::endl;
        o << "*******" << std::endl;
        o << "An object of this class is meant to store an image and its projection parameters" << std::endl;
        o << "and to be use as a texture for a_element (a_trianglecloud in particular)" << std::endl;
        o << "Commands:" << std::endl;
        o << "--------" << std::endl;
        o << "type: returns the string 'a_image'" << std::endl;
        o << "image 'filename': load an image" << std::endl;
        o << "pmatrix 'filename': load the P project matrix" << std::endl;
        o << "                    see p_compute(1) to compute the matrix of a given image" << std::endl;
        o << "name: set/get the name of the object" << std::endl;
        return o.str();
}
//---------------------------------------------------------------------------
void a_image::file_exist(const std::string& file) const
{
        std::ifstream in(file.c_str());
        if (!in)
                throw file_error();
        in.close();
}
//---------------------------------------------------------------------------
void a_image::image(const std::string& image_file)
{
        this->file_exist(image_file);
        if (texture_ !=0)
                texture_->Delete();
        texture_ = vtkTexture::New();
        texture_->InterpolateOn();
        std::string ext = image_file.substr(image_file.find_first_of('.')+1,image_file.size());
        name_ = image_file;
        vtkImageReader2 * reader;
        if ((cmp_nocase(ext,"tif")==0)||(cmp_nocase(ext,"tiff")==0))
                reader = vtkTIFFReader::New();
        else if ((cmp_nocase(ext,"jpg")==0)||(cmp_nocase(ext,"jpeg")==0))
                reader = vtkJPEGReader::New();
        else if (cmp_nocase(ext,"png")==0)
                reader = vtkPNGReader::New();
        reader->SetFileName(const_cast<char *>(image_file.c_str()));
        texture_->SetInputConnection(reader->GetOutputPort());
        reader->Update();
        bb_ = reader->GetOutput()->GetDimensions();
}
//---------------------------------------------------------------------------
void a_image::pmatrix(const std::string& matrix_file)
{
        this->file_exist(matrix_file);
        if (p_ !=0)
                delete p_;
        p_ = new a_pmat;
        std::ifstream ff(matrix_file.c_str());
        ff >> *p_;
        ff.close();
}
//---------------------------------------------------------------------------
void a_image::texture_coordinates(const double * x, float * tcoord) const
{
        a_3dh p3d(x[0],x[1],x[2]);
        a_2dh p2d = p_->project(p3d);
        tcoord[0] = p2d.x();
        tcoord[1] = p2d.y();
        if ((tcoord[0]<0.)||(tcoord[0]>bb_[0])||(tcoord[1]<0.)||(tcoord[1]>bb_[1]))
        {
                tcoord[0] = 0.;
                tcoord[1] = 0.;
        }
        tcoord[0] /= bb_[0];
        tcoord[1] /= bb_[1];
}
//---------------------------------------------------------------------------
void a_image::gettcoords(vtkPoints * points, vtkFloatArray * tcoords) const
{
        int n_pts =  points->GetNumberOfPoints();
        for (int k = 0; k < n_pts; k++)
        {
                double x[3];
                points->GetPoint(k,x);
                float tc[2];
                texture_coordinates(x,tc);
                tcoords->InsertNextTuple(tc);
        }
}
//---------------------------------------------------------------------------
void d_v(a_image * la) {delete la;}
//---------------------------------------------------------------------------
void delete_vector(std::vector<a_image *> & v)
{
        for (int i = 0; i < v.size(); i++)
                delete v[i];
        //      std::for_each(v.begin(),v.end(),d_v);
        v.clear();
}