a_screenlayer.cxx

Go to the documentation of this file.

/*
         Copyright 2002-2022 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_screenlayer.h"
#include "vtkPoints.h"
#include "vtkCellArray.h"
#include "vtkPolyDataMapper.h"
#include "vtkProperty.h"
#include "vtkDelaunay2D.h"
 
//#include "a_screen.h"
 
//---------------------------------------------------------------------------
a_screenlayer::a_screenlayer()
{
        name_ = "noname";
        R_ = G_ = B_ = 1;
        thickness_ = 1;
        int pt[2];
        vtkPoints * points = vtkPoints::New();
        polydata_ = vtkPolyData::New();
        polydata_->Allocate(100,100);
        polydata_->SetPoints(points);
        vtkPolyDataMapper * map = vtkPolyDataMapper::New();
        map->SetInputData(polydata_);
        vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
        actor_ = vtkActor::New();
        actor_->SetMapper(map);
        actor_->GetProperty()->SetColor(0,0,0);
        actor_->DragableOff();
        polydata2_ = vtkPolyData::New();
        polydata2_->Allocate(100,100);
        polydata2_->SetPoints(points);
        vtkPolyDataMapper * map2 = vtkPolyDataMapper::New();
        map2->SetInputData(polydata2_);
        vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
        actor2_ = vtkActor::New();
        actor2_->SetMapper(map2);
        actor2_->GetProperty()->SetColor(0,0,0);
        actor2_->DragableOff();
        empty_ = true;
        surface_actor_ = 0;
        points_polyline_ = 0;
        number_of_surface_point_ = 0;
        has_points_ = has_vertices_ = has_lines_ = has_polylines_ = false;
}
//---------------------------------------------------------------------------
a_screenlayer::~a_screenlayer()
{
        polydata_->Delete();
        actor_->Delete();
}
//---------------------------------------------------------------------------
void a_screenlayer::reset()
{
        polydata_->GetLines()->Reset();
        polydata_->GetVerts()->Reset();
        polydata_->Modified();
        actor_->GetProperty()->SetColor(1,1,1);
        polydata2_->GetLines()->Reset();
        polydata2_->GetVerts()->Reset();
        polydata2_->Modified();
        actor2_->GetProperty()->SetColor(1,1,1);
        if (surface_actor_)
        {
                surface_actor_->GetProperty()->SetColor(1,1,1);
                surface_actor_->Modified();
        }
}
//---------------------------------------------------------------------------
void a_screenlayer::color(float r, float g, float b)
{
        if ((r>=0)&&(g>=0)&&(b>=0)&&(r<=1)&&(g<=1)&&(b<=1))
        {
                actor_->GetProperty()->SetColor(r,g,b);
                actor2_->GetProperty()->SetColor(r,g,b);
                if (surface_actor_)
                        surface_actor_->GetProperty()->SetColor(r,g,b);
                R_ = r;         G_ = g;         B_ = b;
        }
}
//---------------------------------------------------------------------------
void a_screenlayer::R(float v)
{
        if ((v>=0)&&(v<=1))
        {
                actor_->GetProperty()->SetColor(v,G_,B_);
                actor2_->GetProperty()->SetColor(v,G_,B_);
                if (surface_actor_)
                        surface_actor_->GetProperty()->SetColor(v,G_,B_);
                R_ = v;
        }
}
//---------------------------------------------------------------------------
void a_screenlayer::G(float v)
{
        if ((v>=0)&&(v<=1))
        {
                actor_->GetProperty()->SetColor(R_,v,B_);
                actor2_->GetProperty()->SetColor(R_,v,B_);
                if (surface_actor_)
                        surface_actor_->GetProperty()->SetColor(R_,v,B_);
                G_ = v;
        }
}
//---------------------------------------------------------------------------
void a_screenlayer::B(float v)
{
        if ((v>=0)&&(v<=1))
        {
                actor_->GetProperty()->SetColor(R_,G_,v);
                actor2_->GetProperty()->SetColor(R_,G_,v);
                if (surface_actor_)
                        surface_actor_->GetProperty()->SetColor(R_,G_,v);
                B_ = v;
        }
}
//---------------------------------------------------------------------------
void a_screenlayer::thickness(const int v)
{
        if (v>0)
        {
                actor_->GetProperty()->SetPointSize(v);
                actor_->GetProperty()->SetLineWidth(v);
                actor2_->GetProperty()->SetLineWidth(v);
                thickness_ = v;
        }
}
//---------------------------------------------------------------------------
void a_screenlayer::point(double x[3])
{
        if (!has_vertices_)
        {
                has_vertices_ = true;
                vtkCellArray * vertices = vtkCellArray::New();
                polydata_->SetVerts(vertices);
                vertices->Delete();
        }
        vtkIdType pt[1];
        vtkPoints * points = polydata_->GetPoints();
        pt[0] = points->InsertNextPoint(x[0],x[1],x[2]);
        polydata_->GetVerts()->InsertNextCell(1,pt);
        points->GetData()->Modified();
        empty_ = false;
}
//---------------------------------------------------------------------------
void a_screenlayer::point(double x, double y, double z)
{
        if (!has_vertices_)
        {
                has_vertices_ = true;
                vtkCellArray * vertices = vtkCellArray::New();
                polydata_->SetVerts(vertices);
                vertices->Delete();
        }
        vtkPoints * points = polydata_->GetPoints();
        vtkIdType pt = points->InsertNextPoint(x,y,z);
        polydata_->GetVerts()->InsertNextCell(1,&pt);
        points->GetData()->Modified();
        empty_ = false;
}
//---------------------------------------------------------------------------
void a_screenlayer::line(double x[6])
{
        if (!has_lines_)
        {
                has_lines_ = true;
                vtkCellArray * lines = vtkCellArray::New();
                polydata_->SetLines(lines);
                lines->Delete();
        }
        vtkIdType pt[2];
        vtkPoints * points = polydata_->GetPoints();
        pt[0] = points->InsertNextPoint(x[0],x[1],x[2]);
        pt[1] = points->InsertNextPoint(x[3],x[4],x[5]);
        polydata_->GetLines()->InsertNextCell(2,pt);
        points->GetData()->Modified();
        empty_ = false;
}
//---------------------------------------------------------------------------
void a_screenlayer::line(double x1, double y1, double z1, double x2, double y2, double z2)
{
        if (!has_lines_)
        {
                has_lines_ = true;
                vtkCellArray * lines = vtkCellArray::New();
                polydata_->SetLines(lines);
                lines->Delete();
        }
        vtkIdType pt[2];
        vtkPoints * points = polydata_->GetPoints();
        pt[0] = points->InsertNextPoint(x1,y1,z1);
        pt[1] = points->InsertNextPoint(x2,y2,z2);
        polydata_->GetLines()->InsertNextCell(2,pt);
        points->GetData()->Modified();
        empty_ = false;
}
//---------------------------------------------------------------------------
void a_screenlayer::vertex(double x, double y, double z)
{
        if (!points_polyline_)
                points_polyline_ = vtkPoints::New();
        points_polyline_->InsertNextPoint(x,y,z);
}
//---------------------------------------------------------------------------
void a_screenlayer::vertex(double x[3])
{
        if (!points_polyline_)
                points_polyline_ = vtkPoints::New();
        points_polyline_->InsertNextPoint(x[0],x[1],x[2]);
}
//---------------------------------------------------------------------------
void a_screenlayer::endpolyline()
{
        if (!points_polyline_)
                return;
        if (!has_polylines_)
        {
                has_polylines_ = true;
                vtkCellArray * polylines = vtkCellArray::New();
                polydata2_->SetLines(polylines);
                polylines->Delete();
        }
        vtkPoints * points = polydata2_->GetPoints();
        vtkCellArray * lines = polydata2_->GetLines();
        lines->InsertNextCell(points_polyline_->GetNumberOfPoints());
        for (int i = 0; i < points_polyline_->GetNumberOfPoints(); i++)
        {
                double xp[3];
                points_polyline_->GetPoint(i,xp);
                int p = points->InsertNextPoint(xp);
                //              int p = points->InsertNextPoint(xp[0], xp[1], xp[2]);
                lines->InsertCellPoint(p);
        }
        points_polyline_->Delete();
        points_polyline_ = 0;
        points->GetData()->Modified();
//      polydata2_->Modified();
        //std::cerr << "nl: " << polydata2_->GetLines()->GetNumberOfCells() << std::endl;
}
//---------------------------------------------------------------------------
void a_screenlayer::closepolyline()
{
        if (!points_polyline_)
                return;
        if (!has_polylines_)
        {
                has_polylines_ = true;
                vtkCellArray * polylines = vtkCellArray::New();
                polydata2_->SetLines(polylines);
                polylines->Delete();
        }
        vtkPoints * points = polydata2_->GetPoints();
        vtkCellArray * lines = polydata2_->GetLines();
        lines->InsertNextCell(points_polyline_->GetNumberOfPoints()+1);
        int p0;
        for (int i = 0; i < points_polyline_->GetNumberOfPoints(); i++)
        {
                double xp[3];
                points_polyline_->GetPoint(i,xp);
                int p = points->InsertNextPoint(xp);
                lines->InsertCellPoint(p);
                if (i==0) p0=p;
        }
        lines->InsertCellPoint(p0);
        points_polyline_->Delete();
        points_polyline_ = 0;
        points->GetData()->Modified();
//      polydata2_->Modified();
}
//---------------------------------------------------------------------------
void a_screenlayer::surfacepoint(double x, double y, double z)
{
        number_of_surface_point_++;
        if (number_of_surface_point_==1)
                surface_points_ = vtkPoints::New();
        surface_points_->InsertNextPoint(x,y,z);
        surface_points_->Modified();
        if (number_of_surface_point_==3)
        {
                vtkPolyData * data = vtkPolyData::New();
                data->SetPoints(surface_points_);
                surface_points_->Delete();
                vtkDelaunay2D * del = vtkDelaunay2D::New();
                del->SetInputData(data);
                data->Delete();
                del->SetTolerance(0.001);
                vtkPolyDataMapper * map = vtkPolyDataMapper::New();
                map->SetInputConnection(del->GetOutputPort());
                vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
                surface_actor_ = vtkActor::New();
                surface_actor_->SetMapper(map);
                surface_actor_->GetProperty()->SetColor(R_,G_,B_);
                surface_actor_->DragableOff();
        }
}
//---------------------------------------------------------------------------
void a_screenlayer::eraselastpoint()
{
        vtkIdType pt[1];
        vtkCellArray * old_pts = polydata_->GetVerts();
        vtkCellArray * new_pts = vtkCellArray::New();
        old_pts->InitTraversal();
        for (int i = 0; i < old_pts->GetNumberOfCells()-1; i++)
        {
                vtkIdType npts;
                const vtkIdType * pts = nullptr;
                old_pts->GetNextCell(npts, pts);
                new_pts->InsertNextCell(npts, pts);
        }
        polydata_->SetVerts(new_pts);
        new_pts->Delete();
        new_pts->Modified();
//      polydata_->Modified();
}
//---------------------------------------------------------------------------
void a_screenlayer::eraselastline()
{
        vtkIdType pt[1];
        vtkCellArray * old_lis = polydata_->GetLines();
        vtkCellArray * new_lis = vtkCellArray::New();
        old_lis->InitTraversal();
        for (int i = 0; i < old_lis->GetNumberOfCells()-1; i++)
        {
                vtkIdType npts;
                const vtkIdType * pts = nullptr;
                old_lis->GetNextCell(npts, pts);
                new_lis->InsertNextCell(npts, pts);
        }
        polydata_->SetLines(new_lis);
        new_lis->Delete();
        polydata_->Modified();
}
//---------------------------------------------------------------------------
void a_screenlayer::eraselastpolyline()
{
        vtkIdType pt[1];
        vtkCellArray * old_lis = polydata2_->GetLines();
        vtkCellArray * new_lis = vtkCellArray::New();
        old_lis->InitTraversal();
        for (int i = 0; i < old_lis->GetNumberOfCells()-1; i++)
        {
                vtkIdType npts;
                const vtkIdType * pts = nullptr;
                old_lis->GetNextCell(npts, pts);
                new_lis->InsertNextCell(npts, pts);
        }
        polydata2_->SetLines(new_lis);
        new_lis->Delete();
        polydata2_->Modified();
}
//---------------------------------------------------------------------------
void a_screenlayer::dxfout(std::ostream& o) const
{
        vtkIdType npt;
        const vtkIdType * ref_pt = nullptr;
        double pt[3];
        int   stop;
 
        //for each point
        vtkCellArray * cells;
        cells = polydata_->GetVerts();
        cells->InitTraversal();
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        polydata_->GetPoint(ref_pt[0],pt);
                        o << " 0" << std::endl << "POINT" << std::endl;
                        o << " 8" << std::endl << name_ << std::endl;
                        o << " 10" << std::endl << pt[0] << std::endl;
                        o << " 20" << std::endl << pt[1] << std::endl;
                        o << " 30" << std::endl << pt[2] << std::endl;
                }
        }
        while (stop != 0);
 
        //for each line
        cells = polydata_->GetLines();
        cells->InitTraversal();
        npt = 2;
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        polydata_->GetPoint(ref_pt[0],pt);
                        o << " 0" << std::endl << "LINE" << std::endl;
                        o << " 8" << std::endl << name_ << std::endl;
                        o << " 10" << std::endl << pt[0] << std::endl;
                        o << " 20" << std::endl << pt[1] << std::endl;
                        o << " 30" << std::endl << pt[2] << std::endl;
                        polydata_->GetPoint(ref_pt[1],pt);
                        o << " 11" << std::endl << pt[0] << std::endl;
                        o << " 21" << std::endl << pt[1] << std::endl;
                        o << " 31" << std::endl << pt[2] << std::endl;
                }
        }
        while (stop != 0);
 
        //for polyline
        cells = polydata2_->GetLines();
        cells->InitTraversal();
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        o << " 0" << std::endl << "POLYLINE" << std::endl;
                        o << " 8" << std::endl << name_ << std::endl;
                        o << " 66" << std::endl << 1 << std::endl;//?
                        o << " 70" << std::endl << 8 << std::endl;//3d polyline, necessary
                        for (int j=0; j<npt; j++)
                        {
                                polydata_->GetPoint(ref_pt[j],pt);
                                o << " 0" << std::endl << "VERTEX" << std::endl;
                                o << " 8" << std::endl << name_ << std::endl;
                                o << " 10" << std::endl << pt[0] << std::endl;
                                o << " 20" << std::endl << pt[1] << std::endl;
                                o << " 30" << std::endl << pt[2] << std::endl;
                                o << " 70" << std::endl << 32 << std::endl;//3d polyline, necessary
                        }
                        o << " 0" << std::endl << "SEQEND" << std::endl;
                        o << " 8" << std::endl << name_ << std::endl;
                }
        }
        while (stop != 0);
 
        //for surfaces
        if (surface_actor_)
        {
                vtkPolyData * data = (vtkPolyData *)(surface_actor_->GetMapper()->GetInput());
                vtkCellArray * triangles = data->GetPolys();
                int stop;
                int i_tri = -1;
                triangles->InitTraversal();
                do
                {
                        vtkIdType npt;
                        const vtkIdType * ref_pt = nullptr;
                        stop = triangles->GetNextCell(npt,ref_pt);
                        i_tri++;
                        if (stop != 0)
                        {
                                double pt[3];
                                data->GetPoint(ref_pt[0],pt);
                                o << " 0" << std::endl << "3DFACE" << std::endl;
                                o << " 8" << std::endl << name_ << std::endl;
                                o << " 10" << std::endl << pt[0] << std::endl;
                                o << " 20" << std::endl << pt[1] << std::endl;
                                o << " 30" << std::endl << pt[2] << std::endl;
                                data->GetPoint(ref_pt[1],pt);
                                o << " 11" << std::endl << pt[0] << std::endl;
                                o << " 21" << std::endl << pt[1] << std::endl;
                                o << " 31" << std::endl << pt[2] << std::endl;
                                data->GetPoint(ref_pt[2],pt);
                                o << " 12" << std::endl << pt[0] << std::endl;
                                o << " 22" << std::endl << pt[1] << std::endl;
                                o << " 32" << std::endl << pt[2] << std::endl;
                                o << " 13" << std::endl << pt[0] << std::endl;
                                o << " 23" << std::endl << pt[1] << std::endl;
                                o << " 33" << std::endl << pt[2] << std::endl;
                        }
                }
                while (stop != 0);
        }
}
//---------------------------------------------------------------------------
void a_screenlayer::ptin(std::istream& in)
{
        int n_pts;
        double x[3];
        in >> n_pts;
        for (int i=0; i<n_pts; i++)
        {
                in >> x[0] >> x[1] >> x[2];
                this->point(x);
        }
}
//---------------------------------------------------------------------------
void a_screenlayer::ptout(std::ostream& o) const
{
        vtkIdType npt;
        const vtkIdType * ref_pt = nullptr;
        double pt[3];
        int   stop;
 
        //for each point
        vtkCellArray * cells;
        int n_pts = polydata_->GetNumberOfVerts();
        cells = polydata_->GetVerts();
        o << n_pts << std::endl;
        cells->InitTraversal();
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        polydata_->GetPoint(ref_pt[0],pt);
                        o << pt[0] << "\t" << pt[1] << "\t" << pt[2] << std::endl;
                }
        }
        while (stop != 0);
}
//***********************************************************
//-operator>>----------------------------------------------------------------
std::istream& operator>> (std::istream& i, a_screenlayer& l)
{
        i >> l.name_;
        float r,g,b;
        i >> r >> g >> b;
        l.color(r,g,b);
        int t;
        i >> t;
        l.thickness(t);
        int n_point,n_line,n_polyline;
        i >> n_point >> n_line >> n_polyline;
        double x[6];
        for (int k = 0; k < n_point; k++)
        {
                i >> x[0] >> x[1] >> x[2];
                l.point(x);
        }
        for (int k = 0; k < n_line; k++)
        {
                i >> x[0] >> x[1] >> x[2];
                i >> x[3] >> x[4] >> x[5];
                l.line(x);
        }
        for (int k = 0; k < n_polyline; k++)
        {
                int n;
                i >> n;
                for (int j=0; j<n; j++)
                {
                        i >> x[0] >> x[1] >> x[2];
                        l.vertex(x);
                }
                l.endpolyline();
        }
        if ((n_point != 0)||(n_line != 0)||(n_polyline != 0))
                l.empty(false);
        //std::cerr << "nl2: " << l.polydata2_->GetLines()->GetNumberOfCells() << std::endl;
        return i;
}
//-operator<<----------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const a_screenlayer& l)
{
        o << l.name() << std::endl;
        o << l.R() << " " << l.G() << " " << l.B() << std::endl;
        o << l.thickness() << std::endl;
        o <<  l.polydata_->GetVerts()->GetNumberOfCells() << " ";
        o <<  l.polydata_->GetLines()->GetNumberOfCells() << " ";
        o <<  l.polydata2_->GetLines()->GetNumberOfCells() << std::endl;
 
        vtkIdType npt;
        const vtkIdType * ref_pt = nullptr;
        double pt[3];
        int   stop;
 
        //for each point
        vtkCellArray * cells;
        cells = l.polydata_->GetVerts();
        cells->InitTraversal();
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        l.polydata_->GetPoint(ref_pt[0],pt);
                        o << pt[0] << " " << pt[1] << " " << pt[2] << std::endl;
                }
        }
        while (stop != 0);
 
        //for each line
        cells = l.polydata_->GetLines();
        cells->InitTraversal();
        npt = 2;
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        l.polydata_->GetPoint(ref_pt[0],pt);
                        o << pt[0] << " " << pt[1] << " " << pt[2] << " ";
                        l.polydata_->GetPoint(ref_pt[1],pt);
                        o << pt[0] << " " << pt[1] << " " << pt[2] << std::endl;
                }
        }
        while (stop != 0);
 
        //for each polyline
        cells = l.polydata2_->GetLines();
        cells->InitTraversal();
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        o << npt << std::endl;
                        for (int i=0; i<npt; i++)
                        {
                                l.polydata2_->GetPoint(ref_pt[i],pt);
                                o << pt[0] << " " << pt[1] << " " << pt[2] << std::endl;
                        }
                }
        }
        while (stop != 0);
 
        return o;
}
//---------------------------------------------------------------------------
void a_screenlayer::open(const std::string file)
{
        std::ifstream ff(file.c_str());
        if (ff) ff >> *this;
}
//---------------------------------------------------------------------------
void a_screenlayer::save(const std::string file)
{
        std::ofstream ff(file.c_str());
        if (ff) ff << *this;
}
//---------------------------------------------------------------------------
void a_screenlayer::append(const a_screenlayer& l)
{
        name_ = l.name();
        //      R_ = l.R();     G_ = l.G();     B_ = l.B();
        //      actor_->GetProperty()->SetColor(R_,G_,B_);
        color(l.R(),l.G(),l.B());
        thickness(l.thickness());
 
        vtkIdType npt;
        const vtkIdType * ref_pt = nullptr;
        double pt1[3];
        double pt2[3];
        int   stop;
 
        //for each point
        vtkCellArray * cells;
        cells = l.polydata_->GetVerts();
        cells->InitTraversal();
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        l.polydata_->GetPoint(ref_pt[0],pt1);
                        this->point(pt1[0],pt1[1],pt1[2]);
                }
        }
        while (stop != 0);
 
        //for each line
        cells = l.polydata_->GetLines();
        cells->InitTraversal();
        npt = 2;
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        l.polydata_->GetPoint(ref_pt[0],pt1);
                        l.polydata_->GetPoint(ref_pt[1],pt2);
                        this->line(pt1[0],pt1[1],pt1[2],pt2[0],pt2[1],pt2[2]);
                }
        }
        while (stop != 0);
 
        //for each polyline
        cells = l.polydata2_->GetLines();
        cells->InitTraversal();
        do
        {
                stop = cells->GetNextCell(npt,ref_pt);
                if (stop != 0)
                {
                        for (int i=0; i<npt; i++)
                        {
                                l.polydata2_->GetPoint(ref_pt[i],pt1);
                                this->vertex(pt1[0],pt1[1],pt1[2]);
                        }
                        this->endpolyline();
                }
        }
        while (stop != 0);
}
//---------------------------------------------------------------------------
void a_screenlayer::reset_mapper_clipping()
{
        //      std::cout << *(actor_->GetMapper());
        double b[6];
        polydata_->Modified();
        actor_->GetMapper()->Update();
        actor_->GetMapper()->GetBounds(b);
        polydata_->GetPoints()->Modified();
        polydata_->ComputeBounds();
        polydata_->GetBounds(b);
        std::cout << name_ << ": ";
        for (int k=0; k<6; k++) std::cout << b[k] << " ";
        std::cout << std::endl;
}
//---------------------------------------------------------------------------
void d_v(a_screenlayer * la) {delete la;}
//---------------------------------------------------------------------------
void delete_vector(std::vector<a_screenlayer *> & v)
{
        for (int i = 0; i < v.size(); i++)
                delete v[i];
        //      std::for_each(v.begin(),v.end(),d_v);
        v.clear();
}