orient.cxx

Go to the documentation of this file.

/*
         Copyright 2002-2019 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 <iostream>
#include <iomanip>
#include <string>
#include <fstream>
#include <sstream>
 
#include "a_point.h"
#include "a_pos.h"
#include "a_mat_c.h"
 
#include "SimpleOpt.h"
 
enum { OPT_HELP, OPT_ORI, OPT_REF, OPT_DIR, OPT_PREC, OPT_MATRIX };
 
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_DIR,_T("-x"),     SO_NONE    },
        { OPT_DIR,_T("-y"),     SO_NONE    },
        { OPT_PREC,_T("-p"),     SO_REQ_SEP   },
        { OPT_PREC,_T("--precision"),     SO_REQ_SEP   },
        { OPT_ORI,_T("-ox"),     SO_REQ_SEP   },
        { OPT_ORI,_T("-oy"),     SO_REQ_SEP   },
        { OPT_ORI,_T("-oz"),     SO_REQ_SEP   },
        { OPT_REF,_T("-px"),     SO_REQ_SEP   },
        { OPT_REF,_T("-py"),     SO_REQ_SEP   },
        { OPT_REF,_T("-pz"),     SO_REQ_SEP   },
        { OPT_MATRIX,_T("-m"),     SO_REQ_SEP   },
        { OPT_MATRIX,_T("--matrix"),     SO_REQ_SEP   },
        { OPT_HELP,_T("-?"),     SO_NONE    },
        { OPT_HELP,_T("-h"),     SO_NONE    },
        { OPT_HELP,_T("--help"), SO_NONE    },
        SO_END_OF_OPTIONS
};
 
const double pi = 3.14159265358979;
//---------------------------------------------------------------------------
int error(int val)
{
#include "orient.help"
        return val;
}
//---------------------------------------------------------------------------
int main( int argc, char *argv[] )
{
        std::string code("x");
        int pre = 6;
        a_point ori(0.,0.,0.);
        a_point p(1.,0.,0.);
        a_pos mat;
        bool with_matrix = false;
        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_DIR)
                        {
                                std::string code0(args.OptionText());
                                code = code0.substr(1,1);
                        }
                        else if (args.OptionId() == OPT_ORI)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                double val;
                                in >> val;
                                std::string dir(args.OptionText());
                                if (dir == "-ox") ori.x(val);
                                else if (dir == "-oy") ori.y(val);
                                else if (dir == "-oz") ori.z(val);
                        }
                        else if (args.OptionId() == OPT_REF)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                double val;
                                in >> val;
                                std::string dir(args.OptionText());
                                if (dir == "-px") p.x(val);
                                else if (dir == "-py") p.y(val);
                                else if (dir == "-pz") p.z(val);
                        }
                        else if (args.OptionId() == OPT_PREC)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                int prec;
                                in >> prec;
                                if ((prec >= 0)&&(prec < 14))
                                        pre = prec;
                        }
                        else if (args.OptionId() == OPT_MATRIX)
                        {
                                std::ifstream in(args.OptionArg());
                                if (!in)
                                {
                                        std::cerr << "cannot open file: '" << args.OptionArg() << "'" << std::endl;
                                        return error(-2);
                                }
                                else
                                {
                                        try { in >> mat; }
                                        catch (...)
                                        {
                                                std::cerr << "The matrix should be 4x4! Take a look to the manual page." <<  std::endl << std::endl;
                                                return error(-3);
                                        }
                                        with_matrix = true;
                                }
                        } 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
                }
        }
        a_point nx,ny;
        a_point nz(0,0,1);
        a_point nref = p-ori;
        nref.z(0);
        nref.normalise();
        if (code=="x")
        {
                nx = nref;
                nx.y(-nref.y());
                ny = cross(nz,nx).normalise();
        }
        else
        {
                ny = nref;
                ny.x(-nref.x());
                nx = cross(ny,nz).normalise();
        }
        int npts;
        std::cin >> npts;
        std::cout << npts << std::endl;
        std::cout << std::fixed << std::setprecision(pre);
        for (unsigned int k = 0; k < npts; k++)
        {
                if (with_matrix)
                {
                        a_mat_c x0(4);
                        a_mat_c x(4);
                        x0(3) = 1.;
                        x(3) = 1.;
                        std::cin >> x0(0) >> x0(1) >> x0(2);
                        x = mat*x0;
                        if (x(3)!=0.)
                                std::cout << x(0)/x(3) << " " << x(1)/x(3) << " " << x(2)/x(3) << std::endl;
                        else
                        {
                                std::cerr << "point projected to infinity! Inspect output before use!!" << std::endl;
                                std::cout << x(0) << " " << x(1) << " " << x(2) << " " << x(3) << " inf" << std::endl;
                        }
                }
                else
                {
                        a_point x;
                        std::cin >> x;
                        x.rotate(nx,ny,nz).translate(ori.x(),ori.y(),ori.z());
                        std::cout << x << std::endl;
                }
        }
#include "copy.h"
        return 0;
}