a_pointcloud.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_pointcloud.h"
#include "vtkPoints.h"
#include "vtkCellArray.h"
#include "vtkPolyDataMapper.h"
#include "vtkProperty.h"
#include "vtkMatrix4x4.h"
 
//---------------------------------------------------------------------------
a_pointcloud::a_pointcloud() : a_element()
{
        int pt[2];
        vtkPoints * points = vtkPoints::New();
        polydata_->SetPoints(points);
        points->Delete();
        has_points_ = false;
        this->logname();
}
//---------------------------------------------------------------------------
a_pointcloud::~a_pointcloud()
{
}
//---------------------------------------------------------------------------
const std::string a_pointcloud::help()
{
        std::ostringstream o;
        o << "************" << std::endl;
        o << "a_pointcloud" << 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 point cloud in a_canvas object" << std::endl;
        o << "Commands:" << std::endl;
        o << "--------" << std::endl;
        o << "np: get number of points" << std::endl;
        o << "clear: empty the object" << std::endl;
        o << "eraselastpoint: erase the last drawn point" << std::endl;
        o << "point 'x''y' 'z': add a point" << std::endl;
        o << "point 'a_point': add a point" << std::endl;
        o << "append 'a_pointcloud': add points from another a_pointcloud" << std::endl;
        o << "dxfout 'file': export a dxf file with the points" << std::endl;
        o << a_element::help();
        return o.str();
}
//---------------------------------------------------------------------------
int a_pointcloud::np() const
{
        return polydata_->GetVerts()->GetNumberOfCells();
}
//---------------------------------------------------------------------------
void a_pointcloud::point(double x, double y, double z)
{
        vtkPoints * points = polydata_->GetPoints();
        vtkIdType pt = points->InsertNextPoint(x,y,z);
        polydata_->GetVerts()->InsertNextCell(1,&pt);
        points->Modified();
        empty_ = false;
        has_points_ = true;
}
//---------------------------------------------------------------------------
void a_pointcloud::point(double x[3])
{
        this->point(x[0],x[1],x[2]);
}
//---------------------------------------------------------------------------
void a_pointcloud::point(const a_point& p)
{
        this->point(p.x(),p.y(),p.z());
}
//---------------------------------------------------------------------------
void a_pointcloud::eraselastpoint()
{
        int 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->Modified();
        new_pts->Delete();
        this->render();
}
//---------------------------------------------------------------------------
void a_pointcloud::dxfout(std::ostream& o) const
{
        vtkMatrix4x4 * mat = actor_->GetMatrix();
        vtkCellArray * cells;
        cells = polydata_->GetVerts();
        int n_pts = polydata_->GetNumberOfVerts();
        cells->InitTraversal();
        for (int k = 0; k < n_pts; k++)
        {
                vtkIdType npt;
                const vtkIdType * ref_pt = nullptr;
                double pt[4];
                pt[3] = 1.;
                cells->GetNextCell(npt,ref_pt);
                polydata_->GetPoint(ref_pt[0],pt);
                mat->MultiplyPoint(pt,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;
        }
}
//---------------------------------------------------------------------------
std::vector<a_point> a_pointcloud::cloud() const
{
        vtkMatrix4x4 * mat = actor_->GetMatrix();
        vtkCellArray * cells;
        cells = polydata_->GetVerts();
        int n_pts = polydata_->GetNumberOfVerts();
        std::vector<a_point> cloud;
        cells->InitTraversal();
        for (int k = 0; k < n_pts; k++)
        {
                vtkIdType npt;
                const vtkIdType * ref_pt = nullptr;
                double pt[4];
                pt[3] = 1.;
                cells->GetNextCell(npt,ref_pt);
                polydata_->GetPoint(ref_pt[0],pt);
                mat->MultiplyPoint(pt,pt);
                a_point point(pt[0],pt[1],pt[2]);
                cloud.push_back(point);
        }
        return cloud;
}
//---------------------------------------------------------------------------
void a_pointcloud::read(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_pointcloud::write(std::ostream& o) const
{
        vtkMatrix4x4 * mat = actor_->GetMatrix();
        vtkCellArray * cells = polydata_->GetVerts();
        int n_pts = polydata_->GetNumberOfVerts();
        o << n_pts << std::endl;
        cells->InitTraversal();
        for (int k = 0; k < n_pts; k++)
        {
                vtkIdType npt;
                const vtkIdType * ref_pt = nullptr;
                double pt[4];
                pt[3] = 1.;
                cells->GetNextCell(npt,ref_pt);
                polydata_->GetPoint(ref_pt[0],pt);
                mat->MultiplyPoint(pt,pt); 
                o << pt[0] << " " << pt[1] << " " << pt[2] << std::endl;
        }
}
//---------------------------------------------------------------------------
void a_pointcloud::append(const a_pointcloud& l)
{
        name_ = l.name();
        color(l.R(),l.G(),l.B());
        thickness(l.thickness());
        vtkCellArray * cells = l.polydata_->GetVerts();
        int n_pts = l.polydata_->GetNumberOfVerts();
        cells->InitTraversal();
        for (int k = 0; k < n_pts; k++)
        {
                vtkIdType npt;
                const vtkIdType * ref_pt = nullptr;
                double pt[4];
                pt[3] = 1.;
                cells->GetNextCell(npt,ref_pt);
                l.polydata_->GetPoint(ref_pt[0],pt);
                this->point(pt[0],pt[1],pt[2]);
        }
}
//---------------------------------------------------------------------------
void a_pointcloud::clear()
{
        polydata_->GetVerts()->Reset();
        polydata_->GetVerts()->Squeeze();
        polydata_->GetPoints()->Reset();
        polydata_->GetPoints()->Squeeze();
        has_points_ = false;
}
//---------------------------------------------------------------------------
void a_pointcloud::reset_mapper_clipping()
{
        polydata_->GetPoints()->Modified();
        a_element::reset_mapper_clipping();
}