h_remap.cxx

Go to the documentation of this file.

/*
         Copyright 2008-2018 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 "a_image_defo.h"
#include "SimpleOpt.h"
#include <iostream>
#include <sstream>
 
#include <vnl/vnl_matrix.h>
#include <vnl/algo/vnl_matrix_inverse.h>
 
enum { OPT_HELP, OPT_H, OPT_BOX, OPT_GETBOX};
 
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_H,  _T("-H"),     SO_REQ_SEP },
        { OPT_BOX,  _T("-xm"),     SO_REQ_SEP },
        { OPT_BOX,  _T("-xM"),     SO_REQ_SEP },
        { OPT_BOX,  _T("-ym"),     SO_REQ_SEP },
        { OPT_BOX,  _T("-yM"),     SO_REQ_SEP },
        { OPT_GETBOX, _T("-b"),     SO_NONE    },
        { OPT_GETBOX, _T("--get-box"),     SO_NONE    },
        { OPT_HELP, _T("-?"),     SO_NONE    },
        { OPT_HELP, _T("-h"),     SO_NONE    },
        { OPT_HELP, _T("--help"), SO_NONE    },
        SO_END_OF_OPTIONS
};
 
//----------------------------------------------------------------------------
class a_h_remap: public a_image_defo
{
        public:
                a_h_remap(const vnl_matrix<double>& H);
                void new_coordinates(double xo, double yo, double& xn, double& yn);
                bool old_coordinates(double xn, double yn, double& xo, double& yo);
        protected:
                vnl_matrix<double> H_;
                vnl_matrix<double> Hinv_;
};
 
//---------------------------------------------------------------------------
a_h_remap::a_h_remap(const vnl_matrix<double>& H)
{
        H_ = H;
        Hinv_ = vnl_matrix_inverse<double>(H).as_matrix();
        /*
                 for (int i=0;i<3;i++)
                 {
                 for (int j=0;j<3;j++)
                 std::cerr << Hinv_(i,j) << " ";
                 std::cerr << std::endl;
                 }
                 */
}
//---------------------------------------------------------------------------
void a_h_remap::new_coordinates(double xo, double yo, double& xn, double& yn)
{
        vnl_vector<double> po(3);
        po(0) = xo;
        po(1) = yo;
        po(2) = 1.;
        vnl_vector<double> pn = H_*po;
        xn = pn(0)/pn(2);
        yn = pn(1)/pn(2);
        //std::cerr << xo << " " << yo << " - " << xn << " " << yn << std::endl;
}
//---------------------------------------------------------------------------
bool a_h_remap::old_coordinates(double xn, double yn, double& xo, double& yo)
{
        vnl_vector<double> pn(3);
        pn(0) = xn;
        pn(1) = yn;
        pn(2) = 1.;
        vnl_vector<double> po = Hinv_*pn;
        xo = po(0)/po(2);
        yo = po(1)/po(2);
        if (xo<(double)box_in_[0]) return false;
        if (xo>(double)box_in_[1]) return false;
        if (yo<(double)box_in_[2]) return false;
        if (yo>(double)box_in_[3]) return false;
        return true;
}
//---------------------------------------------------------------------------
int error(int val)
{
#include "h_remap.help"
        return val;
}
//---------------------------------------------------------------------------
int main(int argc, char ** argv)
{
        vnl_matrix<double> H(3,3);
        vnl_matrix<double> Hinv(3,3);
        bool given_h = false;
        bool get_box_out = false;
        int xm, xM, ym, yM;
        int val_code = 1000000;
        xm = xM = ym = yM = val_code;
        CSimpleOpt args(argc, argv, g_rgOptions);
        while (args.Next())
        {
                if (args.LastError() == SO_SUCCESS)
                {
                        if (args.OptionId() == OPT_HELP)
                                return error(0);
                        else if (args.OptionId() == OPT_GETBOX)
                                get_box_out = true;
                        else if (args.OptionId() == OPT_H)
                        {
                                std::ifstream in(args.OptionArg());
                                if (!in)
                                {
                                        std::cerr << "Cannot open file" << std::endl;
                                        return error(-2);
                                }
                                int u,v;
                                in >> u >> v;
                                if ((u!=3)||(v!=3))
                                {
                                        std::cerr << "Matrix H should be 3x3" << std::endl;
                                        return error(-3);
                                }
                                for (int i=0;i<3;i++)
                                {
                                        for (int j=0;j<3;j++)
                                        {
                                                in >> H(i,j);
                                                //std::cerr << H(i,j) << " ";
                                        }
                                        //std::cerr << std::endl;
                                }
                                given_h = true;
                        }
                        else if (args.OptionId() == OPT_BOX)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                int val; 
                                in >> val;
                                if (args.OptionText() == std::string("-xm"))
                                        xm = val; 
                                else if (args.OptionText() == std::string("-xM"))
                                        xM = val; 
                                else if (args.OptionText() == std::string("-ym"))
                                        ym = val; 
                                else if (args.OptionText() == std::string("-yM"))
                                        yM = val; 
                        } else
                                return error(-1);
                        // handle option, using OptionId(), OptionText() and OptionArg()
                } else {
                        std::cerr << "Invalid argument: " << args.OptionText() << std::endl;
                        return error(args.LastError());
                        // handle error, one of: SO_OPT_INVALID, SO_OPT_MULTIPLE,
                        // SO_ARG_INVALID, SO_ARG_INVALID_TYPE, SO_ARG_MISSING
                }
        }
        if (get_box_out) 
        { 
                if (args.FileCount() != 1) return error(-4); 
        }
        else
        { 
                if (args.FileCount() != 2) return error(-4); 
        }
        if (!given_h) return error(-5);
 
        a_h_remap remap(H);
        remap.read(args.File(0));
        if (xm != val_code) remap.xm(xm);
        if (xM != val_code) remap.xM(xM);
        if (ym != val_code) remap.ym(ym);
        if (yM != val_code) remap.yM(yM);
        remap.box_out();
        if (get_box_out)
                remap.get_box_out();
        else
        {
                remap.deform();
                remap.write(args.File(1));
        }
        return 0;
}