a_linecloud.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_linecloud.h"
#include "vtkCell.h"
#include "vtkCleanPolyData.h"
#include "vtkPoints.h"
#include "vtkCellArray.h"
#include "vtkPolyData.h"
#include "vtkPolyDataMapper.h"
#include "vtkProperty.h"
#include "vtkMatrix4x4.h"
 
//---------------------------------------------------------------------------
a_linecloud::a_linecloud() : a_element()
{
        int pt[2];
        vtkPoints * points = vtkPoints::New();
        vtkCellArray * lines = vtkCellArray::New();
        polydata_->SetPoints(points);
        points->Delete();
        polydata_->SetLines(lines);
        lines->Delete();
        has_lines_ = false;
        this->logname();
}
//---------------------------------------------------------------------------
a_linecloud::a_linecloud(const a_linecloud& c) : a_element()
{
        int pt[2];
        vtkPoints * points = vtkPoints::New();
        vtkCellArray * lines = vtkCellArray::New();
        polydata_->SetPoints(points);
        points->Delete();
        polydata_->SetLines(lines);
        lines->Delete();
        has_lines_ = false;
        polydata_->DeepCopy(c.polydata_);
        this->logname();
}
//---------------------------------------------------------------------------
a_linecloud::~a_linecloud()
{
        this->clear();
}
//---------------------------------------------------------------------------
const std::string a_linecloud::help()
{
        std::ostringstream o;
        o << "***********" << std::endl;
        o << "a_linecloud" << 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 line cloud in a_canvas object" << std::endl;
        o << "Commands:" << std::endl;
        o << "--------" << std::endl;
        o << "nl: get number of lines" << std::endl;
        o << "clear: empty the object" << std::endl;
        //  o << "eraselastline: erase the last drawn line" << std::endl;
        o << "line 'x1' 'y1' 'z2' 'x1' 'y2' 'z': add a line" << std::endl;
        o << "line 'a_point' 'a_point'" << std::endl;
        o << "append 'a_linecloud': add lines from another a_linecloud" << std::endl;
        o << "dxfout 'file': export a dxf file with the points" << std::endl;
        o << a_element::help();
        return o.str();
}
//---------------------------------------------------------------------------
void a_linecloud::clear()
{
        polydata_->GetLines()->Reset();
        polydata_->GetLines()->Squeeze();
        polydata_->GetPoints()->Reset();
        polydata_->GetPoints()->Squeeze();
        has_lines_ = false;
}
//---------------------------------------------------------------------------
a_linecloud& a_linecloud::operator+=(const a_linecloud& c)
{
        for (int i=0; i<c.nl(); i++)
        {
                a_point p1,p2;
                c.getline(i,p1,p2);
                this->addline(p1,p2);
        }
        return (*this);
}
//---------------------------------------------------------------------------
void a_linecloud::dxfout(std::ostream& o) const
{
}
//---------------------------------------------------------------------------
int a_linecloud::nl() const
{
        return polydata_->GetLines()->GetNumberOfCells();
}
//---------------------------------------------------------------------------
void a_linecloud::read(std::istream& in)
{
        int n_pts;
        double x[3];
        in >> n_pts;
        vtkPoints * points = polydata_->GetPoints();
        vtkCellArray * lines = polydata_->GetLines();
        for (int i=0; i<n_pts; i++)
        {
                vtkIdType r[] = {0,0};
                for (int j=0; j<2; j++)
                {
                        in >> x[0] >> x[1] >> x[2];
                        r[j] = points->InsertNextPoint(x);
                }
                int ref = lines->InsertNextCell(2,r);
        }
        vtkCleanPolyData * clean = vtkCleanPolyData::New();
        clean->SetInputData(polydata_);
        clean->SetTolerance(0.);
        clean->PointMergingOn();
        clean->Update();
        polydata_->DeepCopy(clean->GetOutput());
}
//---------------------------------------------------------------------------
void a_linecloud::write(std::ostream& o) const
{
        vtkMatrix4x4 * mat = actor_->GetMatrix();
        vtkCellArray * lines_n = polydata_->GetLines();
        int n_lis = polydata_->GetNumberOfLines();
        o << n_lis << std::endl;
        lines_n->InitTraversal();
        for (int k = 0; k < n_lis; k++)
        {
                vtkIdType npt;
                const vtkIdType * ref_pt = nullptr;
                double pt1[4];
                double pt2[4];
                pt2[3] = pt1[3] = 1.;
                lines_n->GetNextCell(npt,ref_pt);
                polydata_->GetPoint(ref_pt[0],pt1);
                polydata_->GetPoint(ref_pt[1],pt2);
                mat->MultiplyPoint(pt1,pt1);
                mat->MultiplyPoint(pt2,pt2);
                o << pt1[0] << ' ' << pt1[1] << ' ' << pt1[2] << ' ';
                o << pt2[0] << ' ' << pt2[1] << ' ' << pt2[2] << std::endl;
        }
}
//---------------------------------------------------------------------------
void a_linecloud::getline(const int ref, a_point& p1, a_point& p2) const
{
        if ((ref<0)||(ref>this->nl()))
                return;
        vtkMatrix4x4 * mat = actor_->GetMatrix();
        vtkIdType npt;
        const vtkIdType * ref_pt = nullptr;
        vtkCell * cell = polydata_->GetCell(ref);
        vtkPoints * points = polydata_->GetPoints();
        double x[4];
        x[3] = 1.;
        points->GetPoint(cell->GetPointId(0),x);
        mat->MultiplyPoint(x,x);
        p1.set(x[0],x[1],x[2]);
        points->GetPoint(cell->GetPointId(1),x);
        mat->MultiplyPoint(x,x);
        p2.set(x[0],x[1],x[2]);
}
//---------------------------------------------------------------------------
int a_linecloud::addline(const a_point& p1, const a_point& p2)
{
        vtkCellArray * lines = polydata_->GetLines();
        vtkIdType p[2];
        p[0] = this->addpoint(p1);
        p[1] = this->addpoint(p2);
        int ref = lines->InsertNextCell(2,p);
        polydata_->GetPoints()->Modified();
        return ref;
}
//---------------------------------------------------------------------------
void a_linecloud::append(const a_linecloud& l)
{
        (*this) += l;
}