rib0.cxx

Go to the documentation of this file.

/*
         Copyright 2002-2011 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 <iostream>
#include <vector>
#include <math.h>
#include <sstream>
#include <stdlib.h>
 
#include "a_point.h"
 
#include "SimpleOpt.h"
 
enum { OPT_HELP, OPT_DIR };
 
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_DIR,_T("-d"),     SO_MULTI    },
        { OPT_HELP,_T("-?"),     SO_NONE    },
        { OPT_HELP,_T("-h"),     SO_NONE    },
        { OPT_HELP,_T("--help"), SO_NONE    },
        SO_END_OF_OPTIONS
};
//---------------------------------------------------------------------------
int error(int val)
{
        std::cerr << "rib0:" << std::endl;
        std::cerr << "      extrude a profile along a path" << std::endl;
        std::cerr << "syntax: rib0 path_file profile_file [-?|-h|--help] [-d nx ny nz|--dir nx ny nz] > output_file" << std::endl;
        std::cerr << "        path_file   : '.pt'  file:" << std::endl;
        std::cerr << "         n_pt" << std::endl;
        std::cerr << "         x1 y1 z1" << std::endl;
        std::cerr << "         x2 y2 z2" << std::endl;
        std::cerr << "         ..." << std::endl;
        std::cerr << "        profile_file: '.pt2' file:" << std::endl;
        std::cerr << "         n_pt" << std::endl;
        std::cerr << "         x1 y1" << std::endl;
        std::cerr << "         x2 y2" << std::endl;
        std::cerr << "         ..." << std::endl;
        std::cerr << "        -d: 3D direction of the x axis of the profile_file" << std::endl;
        std::cerr << "author: P.Smars, 2001-2008" << std::endl;
        std::cerr << "version: 2008-04-30" << std::endl;
        return val;
}
//---------------------------------------------------------------------------
std::vector<a_point *> path;
//---------------------------------------------------------------------------
a_point dir(int i, int l)
{
        a_point d;
        int imin = i;
        int imax = i;
        if (imin>0)
                imin -= 1;
        if (imax<l-1)
                imax += 1;
        return (*path[imax]-*path[imin]).normalise();
}
//---------------------------------------------------------------------------
a_point normal(int i, int l)
{
        const a_point vertical(0,0,1);
        a_point d;
        const double cosv_lim = 0.95;
        bool changed;
        double cosv;
        int imin = i;
        int imax = i;
        do 
        {
                changed = false;
                if (imin>0)
                {
                        changed = true;
                        imin -= 1;
                }
                if (imax<l-1)
                {
                        changed = true;
                        imax += 1;
                }
                d = (*path[imax]-*path[imin]).normalise();
                cosv = fabs(d*vertical);
        } while ((cosv>cosv_lim)&&changed);
        if (!changed)
        {
                std::cerr << "the path is nearly vertical" << std::endl;
                std::cerr << "you should define the direction of the normal to the structure with the -d option" << std::endl;
                std::cerr << "(this is also the 3D direction of the x axis of the profile file)" << std::endl;
                exit(-2);
        }
        return (cross(vertical,d)).normalise();
}
//---------------------------------------------------------------------------
int main( int argc, char *argv[] )
{
        a_point u;
        bool without_normal = true;
        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)
                        {
                                char ** arg0 = args.MultiArg(3);
                                if (!arg0) 
                                {
                                        std::cerr << "the number of arguments is not correct" << std::endl;
                                        return error(-2);
                                }
                                double x[3];
                                for (int i = 0; i < 3; i++) 
                                {
                                        std::istringstream in(arg0[i]);
                                        in >> x[i];
                                }
                                u.set(x[0],x[1],x[2]);
                                u.normalise();
                                if (u.norm()==0.) return error(-2);
                                without_normal = false;
                        } 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() != 2) return error(-3);
 
        std::ifstream f_path(args.File(0));
        if (!f_path) {std::cerr << "file '" << args.File(1) << "' does not exist" << std::endl; return error(-4);}
        std::ifstream f_temp(args.File(1));
        if (!f_temp) {std::cerr << "file '" << args.File(0) << "' does not exist" << std::endl; return error(-5);}
        //read the path 
        int n_path;
        a_point * pt;
        f_path >> n_path;
        path.resize(n_path);
        for (int k = 0; k < n_path; k++)
        {
                double x,y,z;
                f_path >> x >> y >> z;
                pt = new a_point(x,y,z);
                path[k] =pt;
        }
        f_path.close();
 
        //read the profile
        int n_temp;
        f_temp >> n_temp;
        std::vector<a_point *> temp(n_temp);
        for (int k = 0; k < n_temp; k++)
        {
                double x,y;
                f_temp >> x >> y;
                pt = new a_point(x,y,0);
                temp[k] = pt;
        }
        f_temp.close();
 
        a_point vertical(0,0,1);
        std::cout << n_path*n_temp << std::endl;
        for (int k = 0; k < n_path; k++)
        {
                a_point pt0 = *path[k];
                a_point dt = dir(k,n_path); //find the average direction at that point
                if (without_normal)
                        u = normal(k,n_path); //average normal to the plane of the structure at that point
                a_point v = (cross(dt,u)).normalise();
                for (int m = 0; m < n_temp; m++)
                {
                        a_point point0 = *temp[m];
                        a_point pointn = pt0;
                        pointn += (point0.x())*u;
                        pointn += (point0.y())*v;
                        std::cout << pointn << std::endl;
                }
        }
        std::cout << (n_path-1)*(n_temp-1)*2 << std::endl;
        for (int k = 0; k < n_path-1; k++)
        {
                for (int m = 0; m < n_temp-1; m++)
                {
                        int i1 = k*n_temp+m;
                        int i2 = i1+1;
                        int j1 = i1+n_temp;
                        int j2 = j1+1;
                        std::cout << i1 << "\t" << j2 << "\t" << j1 << std::endl;
                        std::cout << i1 << "\t" << i2 << "\t" << j2 << std::endl;
                }
        }
        return 0;
}