a_element.cxx

Go to the documentation of this file.

/*
         Copyright 2009-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_element.h"
 
#include "vtkCellArray.h"
#include "vtkDataSetMapper.h"
#include "vtkElevationFilter.h"
#include "vtkLookupTable.h"
#include "vtkMatrix4x4.h"
#include "vtkPoints.h"
#include "vtkPointData.h"
//#include "vtkPolyDataMapper.h"
#include "vtkPolyDataNormals.h"
#include "vtkProperty.h"
 
std::ostringstream log_;
 
//---------------------------------------------------------------------------
a_element::a_element()
{
        name_ = "noname";
        R_ = G_ = B_ = 1;
        thickness_ = 1;
        can_ = 0;
        image_ = 0;
        small_ = 1.e-6;
        polydata_ = vtkPolyData::New();
        polydata_->Allocate(100,100);
        vtkLookupTable * lut = vtkLookupTable::New();
        lut->SetHueRange(0.6,0);
        lut->SetSaturationRange(1,1);
        lut->SetValueRange(1,1);
        //      vtkPolyDataMapper * map = vtkPolyDataMapper::New();
        vtkDataSetMapper * map = vtkDataSetMapper::New();
        map->SetInputData(polydata_);
        map->SetScalarRange(0.,1.);
// vtk8?        map->ImmediateModeRenderingOn();
        //              map->InterpolateScalarsBeforeMappingOn(); (not there, no possibility to give colours to elements)
        map->SetLookupTable(lut);
        lut->Delete();
        vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
        actor_ = vtkActor::New();
        actor_->SetMapper(map);
        actor_->GetProperty()->SetColor(1,1,1);
        actor_->GetProperty()->SetPointSize(1);
        //              actor_->GetProperty()->BackfaceCullingOff();
        actor_->DragableOff();
        //              actor_->DragableOn();
        empty_ = true;
}
 
//---------------------------------------------------------------------------
const std::string a_element::help()
{
        std::ostringstream o;
        o << "*********" << std::endl;
        o << "a_element" << std::endl;
        o << "*********" << std::endl;
        o << "This is a graphical element class meant to be included in a_canvas object" << std::endl;
        o << "Commands:" << std::endl;
        o << "--------" << std::endl;
        o << "name: set/get the name of the object" << std::endl;
        o << "empty: check whether it contains data" << std::endl;
        o << "color 'R' 'G' 'B': set the color [default: 1 1 1]" << std::endl;
        o << "R: set/get the red value [0-1]" << std::endl;
        o << "G: set/get the green value [0-1]" << std::endl;
        o << "B: set/get the blue value [0-1]" << std::endl;
        o << "thickness: set/get thickness of lines or points in pixel [default: 1]" << std::endl;
        o << "opacity: set/get opacity of element" << std::endl;
        o << "edges: show or hide the edges" << std::endl;
        o << "smooth: smooth rendering" << std::endl;
        o << "place 'x' 'y' 'z': position the origin of the object at the given point (absolute)" << std::endl;
        o << "translate 'x' 'y' 'z': translate the object (relative)" << std::endl;
        o << "open 'file': read a file containing appropriate data for the container" << std::endl;
        o << "save 'file': save the data to a file" << std::endl;
        o << "save_transform 'file': save the transform matrix [4x4] to a file" << std::endl;
        o << "scale: set/get the scale (set the origin before scaling)" << std::endl;
        o << "scale 'sx' 'sy' 'sz': scaled each dimension indenpendently" << std::endl;
        o << "orient 'roll' (x) 'pitch' (y) 'yaw' (z): orient the element [in degree] (set the origin before)" << std::endl;
        o << "orient: get the orientation" << std::endl;
        o << "origin: set/get origin" << std::endl;
        o << "small: set/get a number considered small [default: ]" << std::endl;
        o << "center: get the center of gravity" << std::endl;
        o << "size: get a representative size" << std::endl;
        o << "bounds: get the bounds of the element" << std::endl;
        o << "minx, maxx, miny, maxy, minz, maxz: get details about the bounds" << std::endl;
        o << "relief x1 y1 z1 x2 y2 z2: color the element in between two points according to distance" << std::endl;
        o << "steps: number of colored bands to use" << std::endl;
        o << "open_scalars 'file': color elements using a scalar file" << std::endl;
        o << "image 'a_image': associate a texture to project on the object" << std::endl;
        o << "imageon: show the image" << std::endl;
        o << "imageoff: hide the image" << std::endl;
        return o.str();
}
//---------------------------------------------------------------------------
void a_element::logname()
{
        log_.str("");
        log_ << this->type() << " $" << name_ << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
a_element::~a_element()
{
        this->clear();
}
//---------------------------------------------------------------------------
void a_element::clear()
{
        polydata_->Delete();
        actor_->Delete();
}
//---------------------------------------------------------------------------
void a_element::render()
{
        if (can_ != 0) can_->render();
}
//---------------------------------------------------------------------------
void a_element::flushlog()
{
        if (can_ != 0)
        {
                for (int i=0;i<log0_.size(); i++)
                {
                        std::string l = log0_[i];
                        int pos = l.find("noname");
                        if (pos != std::string::npos)
                                l.replace(pos,6,name_);
                        std::string st = l.substr(0,3);
                        if (st=="a_")
                        {
                                can_->logfile() << "set " << name_ << " [" << this->type() << "]" << std::endl;
                                can_->logfile() << "$" << name_ << " name " << name_ << std::endl;
                        }
                        else
                                can_->logfile() << l << std::endl;
                }
                log0_.clear();
        }
}
//---------------------------------------------------------------------------
void a_element::log(std::ostringstream& text)
{
        if (can_ != 0) 
                can_->logfile() << text.str() << std::endl;
        else
        {
                std::string l = text.str();
                std::string line = l.replace(l.find('\n'),1,"");
                log0_.push_back(line);
        }
        text.str("");
}
//---------------------------------------------------------------------------
void a_element::reset()
{
        actor_->SetPosition(0.,0.,0.);
        actor_->SetOrientation(0.,0.,0.);
        actor_->SetScale(1.,1.,1.);
        polydata_->Modified();
        //      actor_->GetProperty()->SetColor(1,1,1);
        //      actor_->GetProperty()->SetPointSize(1.);
        //      actor_->GetProperty()->SetLineWidth(1.);
        this->render();
}
//---------------------------------------------------------------------------
void a_element::color(double r, double g, double b)
{
        if ((r>=0)&&(g>=0)&&(b>=0)&&(r<=1)&&(g<=1)&&(b<=1))
        {
                //not working if scalars where used before
                //              actor_->GetMapper()->InterpolateScalarsBeforeMappingOff(); // not sufficient 
                actor_->GetProperty()->SetColor(r,g,b);
                R_ = r;         G_ = g;         B_ = b;
                log_ << "$" << name_ << " color " << r << " " << g << " " << b << std::endl;
                this->log(log_);
                this->render();
        }
}
//---------------------------------------------------------------------------
void a_element::R(double v)
{
        if ((v>=0)&&(v<=1))
        {
                actor_->GetProperty()->SetColor(v,G_,B_);
                R_ = v;
                log_ << "$" << name_ << " R " << v << std::endl;
                this->render();
        }
}
//---------------------------------------------------------------------------
void a_element::G(double v)
{
        if ((v>=0)&&(v<=1))
        {
                actor_->GetProperty()->SetColor(R_,v,B_);
                G_ = v;
                log_ << "$" << name_ << " G " << v << std::endl;
                this->render();
        }
}
//---------------------------------------------------------------------------
void a_element::B(double v)
{
        if ((v>=0)&&(v<=1))
        {
                actor_->GetProperty()->SetColor(R_,G_,v);
                B_ = v;
                log_ << "$" << name_ << " B " << v << std::endl;
                this->render();
        }
}
//---------------------------------------------------------------------------
void a_element::thickness(const int v)
{
        if (v>0)
        {
                actor_->GetProperty()->SetPointSize(v);
                actor_->GetProperty()->SetLineWidth(v);
                thickness_ = v;
                this->render();
                log_ << "$" << name_ << " thickness " << v << std::endl;
                this->log(log_);
        }
}
//---------------------------------------------------------------------------
void a_element::zebra(bool on)
{
        vtkLookupTable * lut = (vtkLookupTable *)actor_->GetMapper()->GetLookupTable();
        if (on)
        {
                unsigned int number_steps = lut->GetNumberOfTableValues();
                for (short i=0; i<number_steps; i++)
                        lut->SetTableValue(i,i%2,i%2,i%2);
                this->render();
        }
        else
        {
                lut->ForceBuild();
                this->greyscale(1);
        }
}
//---------------------------------------------------------------------------
void a_element::greyscale(bool g)
{
        vtkLookupTable * lut = (vtkLookupTable *)actor_->GetMapper()->GetLookupTable();
        if (g)
        {
                lut->SetHueRange(0,0);
                lut->SetSaturationRange(0,0);
                lut->SetValueRange(0,1);
        } else
        {
                lut->SetHueRange(0.6,0);
                lut->SetSaturationRange(1,1);
                lut->SetValueRange(1,1);
        }
        this->render();
}
//---------------------------------------------------------------------------
bool a_element::greyscale() const
{
        vtkLookupTable * lut = (vtkLookupTable *)actor_->GetMapper()->GetLookupTable();
        double a = lut->GetHueRange()[0];
        if (a==0)
                return true;
        return false;
}
//---------------------------------------------------------------------------
void a_element::steps(const int st)
{
        if ((st<0)||(st>255))
                return;
        vtkLookupTable * lut = (vtkLookupTable *)actor_->GetMapper()->GetLookupTable();
        lut->SetNumberOfTableValues(st);
        this->render();
        log_ << "$" << name_ << " steps " << st << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
int a_element::steps() const
{
        vtkLookupTable * lut = (vtkLookupTable *)actor_->GetMapper()->GetLookupTable();
        return lut->GetNumberOfTableValues();
}
//---------------------------------------------------------------------------
void a_element::opacity(const double val)
{
        if ((val<0)||(val>1))
                return;
        actor_->GetProperty()->SetOpacity(val);
        //        actor_->GetBackfaceProperty()->SetOpacity(val);
        this->render();
        log_ << "$" << name_ << " opacity " << val << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::edges(const bool val)
{
        if (val)
        {
                actor_->GetProperty()->EdgeVisibilityOn();
                actor_->GetProperty()->SetEdgeColor(1,1,0);
        }
        else
                actor_->GetProperty()->EdgeVisibilityOff();
        this->render();
        log_ << "$" << name_ << " edges " << val << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::smooth(const bool val)
{
        vtkDataSetMapper * map = (vtkDataSetMapper *)(actor_->GetMapper());
        if (val)
        {
                vtkPolyDataNormals * normals = vtkPolyDataNormals::New();
                normals->SetInputData(polydata_);
                normals->SetFeatureAngle(20);
                map->SetInputConnection(normals->GetOutputPort());
                normals->Delete();
        }
        else
                map->SetInputData(polydata_);
        this->render();
        log_ << "$" << name_ << " smooth " << val << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::relief(const a_point & p1, const a_point & p2)
{
        actor_->GetMapper()->InterpolateScalarsBeforeMappingOn();
        vtkElevationFilter * elevation = vtkElevationFilter::New();
        elevation->SetInputData(polydata_);
        elevation->SetLowPoint(p1.x(),p1.y(),p1.z());
        elevation->SetHighPoint(p2.x(),p2.y(),p2.z());
        elevation->SetScalarRange(0.,1.);
        vtkDataSetMapper * map = (vtkDataSetMapper *)(actor_->GetMapper());
        map->SetInputConnection(elevation->GetOutputPort());
        elevation->Delete();
        this->render();
        log_ << "$" << name_ << " relief ";
        log_ << p1.x() << " " << p1.y() << " " << p1.z() << " ";
        log_ << p2.x() << " " << p2.y() << " " << p2.z() << " " << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::dxfout(std::ostream& o) const
{
}
//---------------------------------------------------------------------------
void a_element::image(a_image & image)
{
        actor_->SetTexture(image.texture());
        vtkFloatArray * tcoords = vtkFloatArray::New();
        tcoords->SetNumberOfComponents(2);
        image.gettcoords(polydata_->GetPoints(),tcoords);
        polydata_->GetPointData()->SetTCoords(tcoords);
        tcoords->Delete();
        this->render();
        image_ = &image;
        log_ << "$" << name_ << " image " << image.name() << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::imageon()
{
        if (image_ != 0)
        {
                actor_->SetTexture(image_->texture());
                this->render();
        }
        log_ << "$" << name_ << " image on" << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::imageoff()
{
        actor_->SetTexture(0);
        this->render();
        log_ << "$" << name_ << " image off" << std::endl;
        this->log(log_);
}
//***********************************************************
//-operator>>----------------------------------------------------------------
std::istream& operator>> (std::istream& i, a_element& l)
{
        l.read(i);
        return i;
}
//-operator<<----------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const a_element& l)
{
        l.write(o);
        return o;
}
//---------------------------------------------------------------------------
void a_element::open(const std::string& file)
{
        std::ifstream ff(file.c_str());
        if (ff) this->read(ff);
        ff.close(); 
        log_ << "$" << name_ << " open " << file << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::save(const std::string& file)
{
        std::ofstream ff(file.c_str());
        if (ff) this->write(ff);
        ff.close(); 
        log_ << "$" << name_ << " save " << file << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::save_transform(const std::string& file)
{
        std::ofstream ff(file.c_str());
        vtkMatrix4x4 * mat = actor_->GetMatrix();
        /*      vtkMatrix4x4 * tr = vtkMatrix4x4::New();
                        vtkMatrix4x4 * itr = vtkMatrix4x4::New();
                        vtkMatrix4x4 * mat2 = vtkMatrix4x4::New();
                        vtkMatrix4x4 * mat3 = vtkMatrix4x4::New();
                        tr->Identity();
                        itr->Identity();
                        double x[3];
                        actor_->GetOrigin(x);
                        tr->SetElement(0,3,x[0]);
                        tr->SetElement(1,3,x[1]);
                        tr->SetElement(2,3,x[2]);
                        itr->SetElement(0,3,-x[0]);
                        itr->SetElement(1,3,-x[1]);
                        itr->SetElement(2,3,-x[2]);
                        vtkMatrix4x4::Multiply4x4(mat,tr,mat2);
                        vtkMatrix4x4::Multiply4x4(itr,mat2,mat3);
                        */
        ff << "4 4" << std::endl;
        for (int i=0; i<4; i++)
                ff << mat->GetElement(i,0) << " " << mat->GetElement(i,1) << " " << mat->GetElement(i,2) << " " << mat->GetElement(i,3) << " " << std::endl;
        ff.close(); 
        log_ << "$" << name_ << " save_transform " << file << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::open_scalars(const std::string& file)
{
        std::ifstream in(file.c_str());
        if (in)
        {
                vtkDoubleArray * scalars = vtkDoubleArray::New();
                scalars->SetNumberOfComponents(1);
                int npts;
                in >> npts;
                for (int i=0; i<npts; i++)
                {
                        double val;
                        in >> val;
                        scalars->InsertNextValue(val);
                }
                //log_ << npts << std::endl;
                in.close();
                actor_->GetMapper()->InterpolateScalarsBeforeMappingOn();
                polydata_->GetPointData()->SetScalars(scalars);
                actor_->GetProperty()->SetInterpolationToFlat();
                this->render();
                log_ << "$" << name_ << " open_scalars " << file << std::endl;
                this->log(log_);
        }
}
//---------------------------------------------------------------------------
void a_element::reset_mapper_clipping()
{
        double b[6];
        polydata_->Modified();
        actor_->GetMapper()->Update();
        actor_->GetMapper()->GetBounds(b);
        polydata_->ComputeBounds();
        polydata_->GetBounds(b);
        std::cout << name_ << ": ";
        for (int k=0; k<6; k++) std::cout << b[k] << " ";
        std::cout << std::endl;
        this->render();
}
//---------------------------------------------------------------------------
void a_element::place(const double x, const double y, const double z)
{
        actor_->SetPosition(x,y,z);
        this->render();
        log_ << "$" << name_ << " place " << x << " " << y << " " << z << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::translate(const double dx, const double dy, const double dz)
{
        double x[3];
        actor_->GetPosition(x);
        actor_->SetPosition(x[0]+dx,x[1]+dy,x[2]+dz);
        this->render();
        log_ << "$" << name_ << " translate " << dx << " " << dy << " " << dz << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::origin(const double x, const double y, const double z)
{
        actor_->SetOrigin(x,y,z);
        this->render();
        log_ << "$" << name_ << " origin " << x << " " << y << " " << z << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::orient(const double x, const double y, const double z)
{
        //      Orientation is specified as X,Y and Z rotations in that order, but they are performed as RotateZ, RotateX, and finally RotateY.
        actor_->SetOrientation(x,y,z);
        this->render();
        log_ << "$" << name_ << " orient " << x << " " << y << " " << z << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::rotate(const double dx, const double dy, const double dz)
{
        actor_->AddOrientation(dx,dy,dz);
        this->render();
        log_ << "$" << name_ << " rotate " << dx << " " << dy << " " << dz << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::scale(const double s)
{
        actor_->SetScale(s,s,s);
        this->render();
        log_ << "$" << name_ << " scale " << s << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
void a_element::scale(const double s1, const double s2, const double s3)
{
        actor_->SetScale(s1,s2,s3);
        this->render();
        log_ << "$" << name_ << " scale " << s1 << " " << s2 << " " << s3 << std::endl;
        this->log(log_);
}
//---------------------------------------------------------------------------
a_point a_element::place() const
{
        double x[3];
        actor_->GetPosition(x);
        return a_point(x);
}
//---------------------------------------------------------------------------
a_point a_element::origin() const
{
        double x[3];
        actor_->GetOrigin(x);
        return a_point(x);
}
//---------------------------------------------------------------------------
a_point a_element::orient() const
{
        double x[3];
        actor_->GetOrientation(x);
        return a_point(x);
}
//---------------------------------------------------------------------------
double a_element::scale() const
{
        double x[3];
        actor_->GetScale(x);
        return x[0]; 
}
//---------------------------------------------------------------------------
a_point a_element::center() const
{
        double b[6];
        actor_->GetBounds(b);
        return a_point((b[0]+b[1])/2.,(b[2]+b[3])/2.,(b[4]+b[5])/2.);
}
//---------------------------------------------------------------------------
double a_element::size() const
{
        double b[6];
        actor_->GetBounds(b);
        a_point p1(b[0],b[2],b[4]);
        a_point p2(b[1],b[3],b[5]);
        return (p2-p1).norm();
}
//---------------------------------------------------------------------------
double a_element::minx() const
{
        double b[6];
        actor_->GetBounds(b);
        return b[0];
}
//---------------------------------------------------------------------------
double a_element::maxx() const
{
        double b[6];
        actor_->GetBounds(b);
        return b[1];
}
//---------------------------------------------------------------------------
double a_element::miny() const
{
        double b[6];
        actor_->GetBounds(b);
        return b[2];
}
//---------------------------------------------------------------------------
double a_element::maxy() const
{
        double b[6];
        actor_->GetBounds(b);
        return b[3];
}
//---------------------------------------------------------------------------
double a_element::minz() const
{
        double b[6];
        actor_->GetBounds(b);
        return b[4];
}
//---------------------------------------------------------------------------
double a_element::maxz() const
{
        double b[6];
        actor_->GetBounds(b);
        return b[5];
}
//---------------------------------------------------------------------------
int a_element::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 d_v(a_element * la) {delete la;}
//---------------------------------------------------------------------------
void delete_vector(std::vector<a_element *> & v)
{
        std::for_each(v.begin(),v.end(),d_v);
        v.clear();
}