a_trianglecloud.cxx

Go to the documentation of this file.

/*
         Copyright 2002-2016 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_trianglecloud.h"
#include "vtkPoints.h"
#include "vtkCellArray.h"
#include "vtkPolyDataMapper.h"
#include "vtkProperty.h"
#include "vtkMatrix4x4.h"
 
//---------------------------------------------------------------------------
a_trianglecloud::a_trianglecloud() : a_element()
{
        int pt[2];
        vtkPoints * points = vtkPoints::New();
        vtkCellArray * triangles = vtkCellArray::New();
        polydata_->SetPoints(points);
        points->Delete();
        polydata_->SetPolys(triangles);
        triangles->Delete();
        has_triangles_ = false;
        this->logname();
}
//---------------------------------------------------------------------------
a_trianglecloud::a_trianglecloud(const a_trianglecloud& c) : a_element()
{
        int pt[2];
        vtkPoints * points = vtkPoints::New();
        vtkCellArray * triangles = vtkCellArray::New();
        polydata_->SetPoints(points);
        points->Delete();
        polydata_->SetPolys(triangles);
        triangles->Delete();
        has_triangles_ = false;
        polydata_->DeepCopy(c.polydata_);
        this->logname();
}
//---------------------------------------------------------------------------
a_trianglecloud::~a_trianglecloud()
{
        this->clear();
}
//---------------------------------------------------------------------------
const std::string a_trianglecloud::help()
{
        std::ostringstream o;
        o << "***************" << std::endl;
        o << "a_trianglecloud" << std::endl;
        o << "***************" << std::endl;
        o << "The class derives from a_element." << std::endl;
        o << "An object of this class is meant to store, manipulate and display a triangle cloud in a_canvas object" << std::endl;
        o << "Commands:" << std::endl;
        o << "--------" << std::endl;
        o << "nt: get number of triangles" << std::endl;
        o << "clear: empty the object" << std::endl;
        //  o << "eraselasttriangle: erase the last drawn triangle" << std::endl;
        o << "triangle 'x1' 'y1' 'z1' 'x2' 'y2' 'z2' 'x3' 'y3' 'z3': add a triangle" << std::endl;
        o << "triangle 'a_point' 'a_point' 'a_point': add a triangle" << std::endl;
        o << "append 'a_pointcloud': add triangles from another a_trianglecloud" << std::endl;
        o << a_element::help();
        return o.str();
}
//---------------------------------------------------------------------------
void a_trianglecloud::clear()
{
        polydata_->GetPolys()->Reset();
        polydata_->GetPolys()->Squeeze();
        //      std::cout << polydata_->GetPolys()->GetSize() << std::endl;
        //      std::cout << polydata_->GetPoints()->GetActualMemorySize() << std::endl;
        polydata_->GetPoints()->Reset();
        polydata_->GetPoints()->Squeeze();
        //      std::cout << polydata_->GetPoints()->GetActualMemorySize() << std::endl;
        has_triangles_ = false;
}
//---------------------------------------------------------------------------
a_trianglecloud& a_trianglecloud::operator+=(const a_trianglecloud& c)
{
        for (int i=0; i<c.nt(); i++)
        {
                a_point p1,p2,p3;
                c.gettriangle(i,p1,p2,p3);
                this->addtriangle(p1,p2,p3);
        }
        return (*this);
}
//---------------------------------------------------------------------------
int a_trianglecloud::nt() const
{
        return polydata_->GetPolys()->GetNumberOfCells();
}
//---------------------------------------------------------------------------
void a_trianglecloud::dxfout(std::ostream& o) const
{
}
//---------------------------------------------------------------------------
void a_trianglecloud::read(std::istream& in)
{
        int n_pts;
        double x[3];
        in >> n_pts;
        vtkPoints * points = polydata_->GetPoints();
        for (int i=0; i<n_pts; i++)
        {
                in >> x[0] >> x[1] >> x[2];
                points->InsertNextPoint(x);
        }
        int n_tris;
        in >> n_tris;
        vtkCellArray * triangles = polydata_->GetPolys();
        for (int k = 0; k < n_tris; k++)
        {
                vtkIdType p[3];
                for (int l = 0; l < 3; l++)
                        in >> p[l];
                triangles->InsertNextCell(3,p);
        }
}
//---------------------------------------------------------------------------
void a_trianglecloud::write(std::ostream& o) const
{
        vtkMatrix4x4 * mat = actor_->GetMatrix();
        vtkPoints * pts_n = polydata_->GetPoints();
        int n_pts =  pts_n->GetNumberOfPoints();
        o << n_pts << std::endl;
        for (int k = 0; k < n_pts; k++)
        {
                double x[4];
                x[3] = 1.;
                pts_n->GetPoint(k,x);
                mat->MultiplyPoint(x,x);
                o << x[0] << '\t' << x[1] << '\t' << x[2] << std::endl;
        }
        vtkCellArray * triangles_n = polydata_->GetPolys();
        int n_tri = polydata_->GetNumberOfPolys();
        o << n_tri << std::endl;
        triangles_n->InitTraversal();
        for (int k = 0; k < n_tri; k++)
        {
                vtkIdType npt;
                const vtkIdType * ref_pt = nullptr;
                triangles_n->GetNextCell(npt,ref_pt);
                o << ref_pt[0] << '\t' << ref_pt[1] << '\t' << ref_pt[2] << std::endl;
        }
}
//---------------------------------------------------------------------------
/*int a_trianglecloud::addpoint(const a_point& p)
        {
        vtkMatrix4x4 * mat = actor_->GetMatrix();
        vtkPoints * points = polydata_->GetPoints();
        int n_pts =  points->GetNumberOfPoints();
        for (int k = 0; k < n_pts; k++)
        {
        double x[4];
        x[3] = 1.;
        points->GetPoint(k,x);
        mat->MultiplyPoint(x,x);
        a_point pn(x[0],x[1],x[2]);
        if ((pn-p).norm() < small_)
        return k;
        }
        double x[] = {p.x(), p.y(), p.z()};
        points->InsertNextPoint(x);
        return n_pts;
        }*/
 
//---------------------------------------------------------------------------
void a_trianglecloud::gettriangle(const int ref, a_point& p1, a_point& p2, a_point& p3) const
{
        //in case of problem, watch a_linecloud, maybe better method
        if ((ref<0)||(ref>this->nt()))
                return;
        vtkMatrix4x4 * mat = actor_->GetMatrix();
        vtkCellArray * triangles = polydata_->GetPolys();
        vtkIdType npt;
        const vtkIdType * ref_pt = nullptr;
        triangles->GetCell(ref, npt, ref_pt);
        vtkPoints * points = polydata_->GetPoints();
        double x[4];
        x[3] = 1.;
        points->GetPoint(ref_pt[0],x);
        mat->MultiplyPoint(x,x);
        p1.set(x[0],x[1],x[2]);
        points->GetPoint(ref_pt[1],x);
        mat->MultiplyPoint(x,x);
        p2.set(x[0],x[1],x[2]);
        points->GetPoint(ref_pt[2],x);
        mat->MultiplyPoint(x,x);
        p3.set(x[0],x[1],x[2]);
}
//---------------------------------------------------------------------------
int a_trianglecloud::addtriangle(const a_point& p1, const a_point& p2, const a_point& p3)
{
        vtkCellArray * triangles = polydata_->GetPolys();
        vtkIdType p[3];
        p[0] = this->addpoint(p1);
        p[1] = this->addpoint(p2);
        p[2] = this->addpoint(p3);
        return triangles->InsertNextCell(3,p);
}
//---------------------------------------------------------------------------
void a_trianglecloud::eraselasttriangle()
{
        polydata_->BuildLinks();
        polydata_->DeleteCell(this->nt()-1);
        polydata_->RemoveDeletedCells();
        polydata_->Modified();
        this->render();
}
//---------------------------------------------------------------------------
void a_trianglecloud::append(const a_trianglecloud& l)
{
        (*this) += l;
}
//---------------------------------------------------------------------------
void a_trianglecloud::reset_mapper_clipping()
{
        polydata_->GetPoints()->Modified();
        polydata_->GetPolys()->Modified();
        a_element::reset_mapper_clipping();
}