a_profile_edit.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 "a_profile_edit.h"
 
#include "vtkCamera.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkPolyData.h"
#include "vtkPoints.h"
#include "vtkProperty.h"
#include "vtkCellArray.h"
#include "vtkPolyDataMapper.h"
#include "vtkActor.h"
#include "a_profile_edit_interactor.h"
 
// .PORTABILITY : ansi C++
 
//***************************************************************************
//---------------------------------------------------------------------------
a_profile_edit::a_profile_edit()
{
}
//---------------------------------------------------------------------------
void a_profile_edit::draw_prof(a_curve_lin * prof, vtkRenderer * ren)
{
        int npts = prof->size();
        vtkPoints * pts = vtkPoints::New();
        for (int i = 0; i < npts; i++)
                pts->InsertNextPoint((*prof)[i]->x(),(*prof)[i]->y(),(*prof)[i]->z());
        vtkCellArray * vertices = vtkCellArray::New();
        vtkCellArray * lines = vtkCellArray::New();
        for (int i = 0; i < npts-1; i++)
        {
                vertices->InsertNextCell(1,&i);
                int p[] = {i, i+1};
                lines->InsertNextCell(2,p);
        }
        vtkPolyData * data = vtkPolyData::New();
        data->SetPoints(pts);
        pts->Delete();
        data->SetVerts(vertices);
        vertices->Delete();
        data->SetLines(lines);
        lines->Delete();
        vtkPolyDataMapper * map = vtkPolyDataMapper::New();
        map->SetInput(data);
        data->Delete();
        vtkActor * actor = vtkActor::New();
        actor->SetMapper(map);
        map->Delete();
        actor->GetProperty()->SetPointSize(3);
        actor->PickableOff();
        actor->DragableOff();
        ren->AddActor(actor);
        actor->Delete();
        pts->GetBounds(bd_);
}
//---------------------------------------------------------------------------
void a_profile_edit::draw_plan(vtkRenderer * ren)
{
        double bx = (bd_[1]-bd_[0])/2.;
        double by = (bd_[3]-bd_[2])/2.;
        vtkPoints * pts = vtkPoints::New();
        pts->InsertNextPoint(bd_[0]-bx,bd_[2]-by,0.);
        pts->InsertNextPoint(bd_[1]+bx,bd_[2]-by,0.);
        pts->InsertNextPoint(bd_[0]-bx,bd_[3]+by,0.);
        pts->InsertNextPoint(bd_[1]+bx,bd_[3]+by,0.);
        vtkCellArray * tri = vtkCellArray::New();
        int pp[] = {0,1,2};
        tri->InsertNextCell(3,pp);
        pp[0] = 1; pp[1] = 3; pp[2] = 2;
        tri->InsertNextCell(3,pp);
        vtkPolyData * data = vtkPolyData::New();
        data->SetPoints(pts);
        pts->Delete();
        data->SetPolys(tri);
        tri->Delete();
        vtkPolyDataMapper * map = vtkPolyDataMapper::New();
        map->SetInput(data);
        data->Delete();
        map->SetResolveCoincidentTopologyToPolygonOffset();
        //              map->SetResolveCoincidentTopologyZShift(.01);
        vtkActor * actor = vtkActor::New();
        actor->SetMapper(map);
        actor->GetProperty()->SetColor(.1,.1,.1);
        actor->PickableOff();
        actor->DragableOff();
        map->Delete();
        ren->AddActor(actor);
        actor->Delete();
}
//---------------------------------------------------------------------------
void getcolor(int ref, double * RGB)
{
        switch (ref)
        {
                case 0:
                        RGB[0] = 1; RGB[1] = 0; RGB[2] = 0;
                        break;
                case 1:
                        RGB[0] = 0; RGB[1] = 1; RGB[2] = 0;
                        break;
                case 2:
                        RGB[0] = 0; RGB[1] = 0; RGB[2] = 1;
                        break;
                case 3:
                        RGB[0] = 1; RGB[1] = 1; RGB[2] = 0;
                        break;
                case 4:
                        RGB[0] = 0; RGB[1] = 1; RGB[2] = 1;
                        break;
                default:
                        RGB[0] = 1; RGB[1] = 0; RGB[2] = 1;
        }
}
//---------------------------------------------------------------------------
void a_profile_edit::draw_refprof(a_curve_lin * prof, vtkRenderer * ren)
{
        static int ref = -1;
        ref++;
        int npts = prof->size();
        vtkPoints * pts = vtkPoints::New();
        for (int i = 0; i < npts; i++)
                pts->InsertNextPoint((*prof)[i]->x(),(*prof)[i]->y(),(*prof)[i]->z());
        double bx = (bd_[1]-bd_[0])/50.;
        double by = (bd_[3]-bd_[2])/50.;
        pts->InsertNextPoint(0.,0.,0.);
        pts->InsertNextPoint(bx,0.,0.);
        pts->InsertNextPoint(0.,by,0.);
        pts->InsertNextPoint(bx,by,0.);
        vtkCellArray * vertices = vtkCellArray::New();
        for (int i = 0; i < npts; i++)
                vertices->InsertNextCell(1,&i);
        vtkCellArray * handle = vtkCellArray::New();
        int p[] = {npts,npts+1,npts+2};
        handle->InsertNextCell(3,p);
        p[0] = npts+1; p[1] = npts+3; p[2] = npts+2;
        handle->InsertNextCell(3,p);
        vtkPolyData * data = vtkPolyData::New();
        data->SetPoints(pts);
        pts->Delete();
        data->SetVerts(vertices);
        vertices->Delete();
        data->SetPolys(handle);
        handle->Delete();
        vtkPolyDataMapper * map = vtkPolyDataMapper::New();
        map->SetInput(data);
        data->Delete();
        vtkActor * actor = vtkActor::New();
        actor->SetMapper(map);
        map->Delete();
        actor->GetProperty()->SetPointSize(2);
        double RGB[3];
        getcolor(ref,RGB);
        actor->GetProperty()->SetColor(RGB);
        ren->AddActor(actor);
        actor->Delete();
}
//---------------------------------------------------------------------------
void a_profile_edit::show(int precision)
{
        a_point x_axis = profile_.x_axis();
        a_point y_axis = profile_.y_axis();
        a_point origin = *profile_[0];
        std::vector<a_point> newpoints;
 
        profile_.flatten2D();
        vtkRenderer * ren = vtkRenderer::New();
        vtkRenderWindow * renWin = vtkRenderWindow::New();
        renWin->AddRenderer(ren);
        ren->Delete();
        a_profile_edit_interactor * style = a_profile_edit_interactor::New();
        style->setpoints(&newpoints);
        style->SetPickColor(.5,1.,1.);
        vtkRenderWindowInteractor * iren = vtkRenderWindowInteractor::New();
        iren->SetRenderWindow(renWin);
        renWin->Delete();
        iren->SetInteractorStyle(style);
 
        this->draw_prof(&profile_,ren);
        this->draw_plan(ren);
 
        for (auto prof:profiles_ref_)
                this->draw_refprof(prof,ren);
 
        ren->GetActiveCamera()->ParallelProjectionOn();
        renWin->SetSize(640,480);
        renWin->Render();
 
        renWin->SetWindowName("profile_edit"); 
        iren->Start();
 
        if (newpoints.size()>0)
        {
                a_curve_lin newprofile;
                for (auto pt:newpoints)
                {
                        auto x = new a_point(pt);
                        newprofile.addpoint(x);
                }
                newprofile.place3D(origin,x_axis,y_axis);
                std::cout << std::fixed << std::setprecision(precision);
                std::cout << newprofile;
        }
}
//***************************************************************************
//---------------------------------------------------------------------------
std::istream& operator>> (std::istream& in, a_profile_edit & p)
{
        in >> p.profile_;
        return in;
}
//---------------------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const a_profile_edit & p)
{
        o << p.profile_;
        return o;
}