bspline.cxx

Go to the documentation of this file.

/*
         Copyright 2002-2015 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 "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkPolyData.h"
#include "vtkPoints.h"
#include "vtkProperty.h"
#include "vtkCellArray.h"
#include "vtkKochanekSpline.h"
#include "vtkPolyDataMapper.h"
#include "vtkActor.h"
 
#include <sstream>
#include <iomanip>
 
#include "SimpleOpt.h"
 
enum { OPT_HELP, OPT_PREC, OPT_VIEW, OPT_CLOSED };
 
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_PREC,_T("-p"),     SO_REQ_SEP    },
        { OPT_PREC,_T("--precision"),     SO_REQ_SEP    },
        { OPT_VIEW,_T("-v"),     SO_NONE    },
        { OPT_VIEW,_T("--view"),     SO_NONE    },
        { OPT_CLOSED,_T("-c"),     SO_NONE    },
        { OPT_CLOSED,_T("--closed"),     SO_NONE    },
        { OPT_HELP,_T("-?"),     SO_NONE    },
        { OPT_HELP,_T("-h"),     SO_NONE    },
        { OPT_HELP,_T("--help"), SO_NONE    },
        SO_END_OF_OPTIONS
};
 
//---------------------------------------------------------------------------
int pre = 6;
bool closed = false;
bool view = false;
int n_output, n_control;
//---------------------------------------------------------------------------
int error(int val)
{
        std::cerr << "bspline:" << std::endl;
        std::cerr << "    create a regular spaced list of point by Kochanek-spline interpolation" << std::endl;
        std::cerr << "syntax: spline number_of_points [-p n_decimals|--precision n_decimals] [-v|--view] [-c|--closed] < input_file > output_file" << std::endl;
        std::cerr << "    -p n_decimals: number of decimals (default 6)" << std::endl;
        std::cerr << "    -v: view results" << std::endl;
        std::cerr << "    -c: curve is closed" << std::endl;
        std::cerr << "author: Pierre Smars, 2001-8" << std::endl;
        std::cerr << "version 2011-04-16" << std::endl;
        return val;
}
//---------------------------------------------------------------------------
void draw(vtkPoints * pts_in, vtkPoints * pts_out)
{
        vtkRenderer * ren = vtkRenderer::New();
        vtkRenderWindow * renWin = vtkRenderWindow::New();
        renWin->AddRenderer(ren);
        ren->Delete();
        vtkInteractorStyleTrackballCamera * style = vtkInteractorStyleTrackballCamera::New();
        vtkRenderWindowInteractor * iren =  vtkRenderWindowInteractor::New();
        iren->SetRenderWindow(renWin);
        renWin->Delete();
        iren->SetInteractorStyle(style);
        vtkCellArray * vertices = vtkCellArray::New();
        for (vtkIdType i = 0; i < n_control; i++)
                vertices->InsertNextCell(1,&i);
        vtkPolyData * data = vtkPolyData::New();
        data->SetPoints(pts_in);
        pts_in->Delete();
        data->SetVerts(vertices);
        vertices->Delete();
        vtkPolyDataMapper * map = vtkPolyDataMapper::New();
        map->SetInputData(data);
        data->Delete();
        vtkActor * actor = vtkActor::New();
        actor->SetMapper(map);
        map->Delete();
        actor->GetProperty()->SetPointSize(3);
        vtkCellArray * vertices2 = vtkCellArray::New();
        for (vtkIdType i = 0; i < n_output; i++)
                vertices2->InsertNextCell(1,&i);
        vtkPolyData * data2 = vtkPolyData::New();
        data2->SetPoints(pts_out);
        pts_out->Delete();
        data2->SetVerts(vertices2);
        vertices2->Delete();
        vtkPolyDataMapper * map2 = vtkPolyDataMapper::New();
        map2->SetInputData(data2);
        data2->Delete();
        vtkActor * actor2 = vtkActor::New();
        actor2->SetMapper(map2);
        map2->Delete();
        actor2->GetProperty()->SetColor(1,1,0);
        ren->AddActor(actor);
        actor->Delete();
        ren->AddActor(actor2);
        actor2->Delete();
        renWin->SetSize(640,480);
        renWin->Render();
        iren->Start();
}
//---------------------------------------------------------------------------
int main(int argc, char ** argv)
{
        double tension = 0;
        double bias = 0;
        double continuity = 0;
        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_VIEW)
                                view = true;
                        else if (args.OptionId() == OPT_CLOSED)
                                closed = true;
                        else if (args.OptionId() == OPT_PREC)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                int precision;
                                in >> precision;
                                if ((precision > 0)&&(precision < 12))
                                        pre = precision;
                        } 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() != 1) return error(-2);
 
        std::ostringstream o(args.File(0));
        std::istringstream in(o.str().c_str());
        in >> n_output;
        n_output--;
 
        vtkKochanekSpline * s[3];
        for (int i = 0; i < 3; i++)
        {
                s[i] = vtkKochanekSpline::New();
                s[i]->SetDefaultTension(tension);
                s[i]->SetDefaultBias(bias);
                s[i]->SetDefaultContinuity(continuity);
        }
        vtkPoints * pts_in, * pts_out;
        if (view)
        {
                pts_in = vtkPoints::New();
                pts_out = vtkPoints::New();
        }
        //input
        std::cin >> n_control; // number of control points
        double dist = 0;
        double x[3], x0[3], x00[3];
        for (int i=0; i < n_control; i++)
        {
                for (int j = 0; j < 3; j++) std::cin >> x[j];
                if (i==0)
                        for (int j = 0; j < 3; j++) x00[j] = x0[j] = x[j];
                else
                        dist += sqrt((x[0]-x0[0])*(x[0]-x0[0])+(x[1]-x0[1])*(x[1]-x0[1])+(x[2]-x0[2])*(x[2]-x0[2]));
                if (dist==0)
                        for (int j = 0; j < 3; j++) s[j]->AddPoint(0,x[j]);
                else
                        for (int j = 0; j < 3; j++) s[j]->AddPoint(dist,x[j]);
                if (view)
                        pts_in->InsertNextPoint(x);
                for (int j = 0; j < 3; j++) x0[j] = x[j];
        }
        if (closed)
        {
                if ((x00[1]!=x[1])||(x00[1]!=x[1])||(x00[1]!=x[1]))
                {
                        dist += sqrt((x00[0]-x0[0])*(x00[0]-x0[0])+(x00[1]-x0[1])*(x00[1]-x0[1])+(x00[2]-x0[2])*(x00[2]-x0[2]));
                        for (int j = 0; j < 3; j++) s[j]->AddPoint(dist,x00[j]);
                }
                for (int j = 0; j < 3; j++)     s[j]->ClosedOn();
        }
 
        //output
        std::cout << n_output+1 << std::endl;
        std::cout << std::fixed << std::setprecision(pre);
        double offset = dist/n_output;
        double t = -offset;
        for (int i=0; i <= n_output; i++)
        {
                t += offset;
                if (view)
                {
                        double x[3];
                        for (int j = 0; j < 3; j++)
                                x[j] = s[j]->Evaluate(t);
                        std::cout << x[0] << "\t" << x[1] << "\t" << x[2] << "\t" << std::endl;
                        pts_out->InsertNextPoint(x);
                }
                else
                        std::cout << s[0]->Evaluate(t) << "\t" << s[1]->Evaluate(t) << "\t" << s[2]->Evaluate(t) << "\t" << std::endl;
        }
 
        if (view)
                draw(pts_in,pts_out);
        return 0;
}