pt2dat.cxx

Go to the documentation of this file.

/*
         Copyright 2008-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 <fstream>
#include <sstream>
#include <iostream>
#include <string>
#include <vector>
#include <math.h>
 
#include "a_point.h"
#include "SimpleOpt.h"
 
enum { OPT_HELP, OPT_NAME };
 
//---------------------------------------------------------------------------
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_HELP, _T("-?"),     SO_NONE    },
        { OPT_HELP, _T("-h"),     SO_NONE    },
        { OPT_HELP, _T("--help"), SO_NONE    },
        { OPT_NAME,  _T("-n"),     SO_REQ_SEP },
        { OPT_NAME,  _T("--name"),     SO_REQ_SEP },
        SO_END_OF_OPTIONS
};
//---------------------------------------------------------------------------
int error(int val)
{
        std::cerr << "pt2dat:" << std::endl;
        std::cerr << "convert 'x y z' file to a calipous 'dat' file (arch modelling)" << std::endl;
        std::cerr << "syntax: pt2dat [-n name|--name name] [-?|-h|--help] density thickness depth < point_file > dat_file" << std::endl;
        std::cerr << "    -n name: give the name to the arch" << std::endl;
        std::cerr << "      (default: arch)" << std::endl;
        std::cerr << "author: P.Smars, 2002-2011" << std::endl;
        std::cerr << "version: 2009-03-24" << std::endl;
        return val;
}
//---------------------------------------------------------------------------
class calipous
{
        public:
                calipous(std::vector<a_point *> *);
                std::string name() const {return name_;}
                void name(const std::string name) {name_ = name;}
                double n_blocks() const {return points_->size()-1;}
                double n_points() const {return points_->size();}
                double density() const {return density_;}
                void density(double val) {density_ = val;}
                double depth() const {return depth_;}
                void depth(double val) {depth_ = val;}
                double thickness() const {return thickness_;}
                void thickness(double val) {thickness_ = val;}
                a_point operator()(const unsigned int i) const {return *(*points_)[i];}
                // output
                friend   std::ostream&    operator<<(std::ostream& o, const calipous& l);
        protected:
                std::vector<a_point *> *                                points_;
                std::string                                             name_;
                double                                                  density_;
                double                                                  thickness_;
                double                                                  depth_;
                double length() const;
};
 
//---------------------------------------------------------------------------
calipous::calipous(std::vector<a_point *> * points)
{
        points_ = points;
        name_ = "arch";
        density_ = 2000;
        thickness_ = 1;
        depth_ = 1;
}
//---------------------------------------------------------------------------
double calipous::length() const
{
        double val = 0;
        a_point x0 = *(*points_)[0];
        for (unsigned int i=0; i<this->n_points(); i++)
        {
                a_point x = *(*points_)[i];
                val += (x-x0).norm();
                x0 = x;
        }
        return val;
}
//---------------------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const calipous& c)
{
        int n_blocks;
        n_blocks = c.n_blocks();
        o << c.name() << std::endl;
        o << c.n_points() << std::endl;
        o << c.density() << std::endl;
        o << "3D" << std::endl;
        a_point origin = c(0);
        a_point end = c(c.n_points()-1);
        a_point az(0,0,1);
        std::cout << origin << std::endl;
        a_point ay = cross(az,end-origin).normalise();
        a_point ax = cross(ay,az).normalise();
        o << ax << std::endl;
        o << ay << std::endl;
        o << "0 0" << std::endl;
        o << c.thickness() << std::endl;
        o << c.depth() << std::endl;
        o << "AA" << std::endl;
        for (unsigned int i=1;i<c.n_points();i++)
        {
                a_point p = c(i);
                a_point d = p-origin;
                double x = d*ax;
                double z = d*az;
                o << x << " " << z << std::endl;
                o << c.thickness() << std::endl;
                o << c.depth() << std::endl;
                o << "AA" << std::endl;
        }
        return o;
}
//---------------------------------------------------------------------------
int main( int argc, char *argv[] )
{
        std::string name("arch");
        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_NAME)
                                name = args.OptionArg();
                        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 (args.FileCount() != 3) return error(-2);
        std::ostringstream o;
        for (short k= 0; k < 3; k++) o << args.File(k) << " ";
        std::istringstream i(o.str().c_str());
        double density, thickness, depth;
        i >> density >> thickness >> depth;
        int npts;
        std::cin >> npts;
        auto points = new std::vector<a_point *>;
        for (unsigned int i = 0; i < npts; i++)
        {
                auto p = new a_point;
                std::cin >> *p;
                points->push_back(p);
        }
        calipous arc(points);
        arc.name(name);
        arc.density(density);
        arc.thickness(thickness);
        arc.depth(depth);
        std::cout << arc;
        delete points;
        return 0;
}