a_canvas.cxx

Go to the documentation of this file.

/*
         Copyright 2002-2017 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 "vtkAppendPolyData.h"
#include "vtkBoxWidget.h"
#include "vtkCamera.h"
#include "vtkCellArray.h"
#include "vtkClipPolyData.h"
#include "vtkCommand.h"
#include "vtkDataSetMapper.h"
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkInteractorStyleTrackballActor.h"
#include "vtkInteractorStyleSwitch.h"
#include "vtkIterativeClosestPointTransform.h"
#include "vtkJPEGWriter.h"
#include "vtkPNGWriter.h"
#include "vtkLight.h"
#include "vtkLightCollection.h"
#include "vtkObject.h"
#include "vtkPlane.h"
#include "vtkPlanes.h"
#include "vtkPlaneWidget.h"
#include "vtkPoints.h"
#include "vtkPolyDataMapper.h"
#include "vtkPolyDataWriter.h"
#include "vtkProperty.h"
#include "vtkRenderLargeImage.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRIBExporter.h"
#include "vtkTIFFWriter.h"
#include "vtkTransform.h"
#include "vtkVRMLExporter.h"
#include "vtkWindowToImageFilter.h"
// #include "vtkXRenderWindowTclInteractor.h"
#include "vtkCellPicker.h"
#include "vtkPropPicker.h"
#include "a_dxf_group.h"
#include "a_dxf_entity.h"
#include "a_dxf_point.h"
#include "a_dxf_line.h"
#include "a_dxf_polyline.h"
#include "a_interactor.h"
 
#include <sstream>
#include <algorithm>
#include "a_canvas.h"
 
#define DE(x) std::cerr << #x << ": " << x << std::endl;
 
const double d2r=3.14159265358979/180.;
const double r2d=180./3.14159265358979;
const double very_small = 0.00001; 
//---------------------------------------------------------------------------
const std::string a_canvas::help()
{
        std::ostringstream o;
        o << "**********" << std::endl;
        o << "a_canvas:" << std::endl;
        o << "**********" << std::endl;
        o << "This is a 3D window class" << std::endl;
        o << "Commands:" << std::endl;
        o << "--------" << std::endl;
        o << "a_canvas C: create a window named C" << std::endl;
        o << "windows can display various types of objects:" << std::endl;
        o << "a_pointcloud, a_linecloud, a_trianglecloud" << std::endl;
        o << "(look at the corresponding help files for details)" << std::endl;
        o << "Object management:" << std::endl;
        o << "................" << std::endl;
        o << "an object receives a handle when it is created" << std::endl;
        o << "  ex: if 'a_pointcloud pts' is used to create an object" << std::endl;
        o << "      'pts' is the object handle" << std::endl;
        o << "      the handle is used to access the functions" << std::endl;
        o << "      'pts name somename' is used to assign the name 'somename' to the object" << std::endl;
        o << "      name and handle should be different!!!" << std::endl;
        o << "object add HANDLE: add/link a new object (created before)" << std::endl;
        o << "object set NAME: set current object" << std::endl;
        o << "object unlink NAME: unlink object" << std::endl;
        o << "object list: return the name list of the existing objects" << std::endl;
        o << "(alternatively: 'object ls')" << std::endl;
        o << "object name: return the name of the current object" << std::endl;
        o << "objecth: return the handle of the current object" << std::endl;
        o << "object exist NAME: check whether object exists (returns 0 or 1)" << std::endl;
        o << "Navigating:" << std::endl;
        o << ".........." << std::endl;
        o << "interact: start mouse control (click 'e' to exit)" << std::endl;
        o << "redraw: refresh screen" << std::endl;
        o << "fit: fit data to screen" << std::endl;
        o << "straighten: put the vertical vertical" << std::endl;
        o << "background R G B: change background color" << std::endl;
        o << "perspective on: perspective view" << std::endl;
        o << "perspective off: parallel view" << std::endl;
        o << "cursor on: show cursor" << std::endl;
        o << "cursor off: hide cursor" << std::endl;
        o << "x: look in the direction of positive x" << std::endl;
        o << "X: look in the direction of negative X" << std::endl;
        o << "y: look in the direction of positive y" << std::endl;
        o << "Y: look in the direction of negative Y" << std::endl;
        o << "z: look in the direction of positive z" << std::endl;
        o << "Z: look in the direction of negative Z" << std::endl;
        o << "azimuth V: set azimuth angle" << std::endl;
        o << "azimuth: get azimuth angle" << std::endl;
        o << "(similar functions for elevation, roll, pich, yaw, distance)" << std::endl;
        o << "up: set Z up" << std::endl;
        o << "camerapoint X Y Z: set view point" << std::endl;
        o << "camerapoint: get view point" << std::endl;
        o << "focalpoint X Y Z: set focal point" << std::endl;
        o << "focalpoint: get focal point" << std::endl;
        o << "light sun: fixed light" << std::endl;
        o << "light spot: light follow camera" << std::endl;
        o << "Input/Output:" << std::endl;
        o << "............" << std::endl;
        o << "save CODE FILE" << std::endl;
        o << "(code: jpeg, png, vec, vrml, vtk)" << std::endl;
        o << "magnification V: set factor of magnification for the production of images" << std::endl;
        o << "scale V: set scale of parallel views" << std::endl;
        o << "scale: get scale of parallel views" << std::endl;
        o << "logfile A_TEXT: log is saved to a a_text object" << std::endl;
        o << "outputfile A_TEXT: output is saved to a a_text object" << std::endl;
        o << "A_TEXT should be created before: ex: a_text NAME" << std::endl;
        o << "(not all functions are documented, to be completed...)" << std::endl;
        return o.str();
}
//---------------------------------------------------------------------------
class testcallback : public vtkCommand
{
        public:
                static testcallback *New() {return new testcallback;}
                void iren(vtkRenderWindowInteractor * iren) {iren_=iren;}
                virtual void Execute(vtkObject *caller, unsigned long, void*)
                {
                        std::cout << "." << std::endl;;
                        iren_->CreateTimer(VTKI_TIMER_UPDATE);
                }
        private:
                vtkRenderWindowInteractor * iren_;
};
//---------------------------------------------------------------------------
class deformcallback : public vtkCommand
{
        public:
                static deformcallback *New() { return new deformcallback; }
                virtual void Execute(vtkObject *caller, unsigned long, void*)
                {
                        vtkTransform *t = vtkTransform::New();
                        vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
                        widget->GetTransform(t);
                        widget->GetProp3D()->SetUserTransform(t);
                        t->Delete();
                }
};
//---------------------------------------------------------------------------
class cutcallback : public vtkCommand
{
        public:
                static cutcallback *New() { return new cutcallback; }
                void set_plane(vtkPlane * plane) {plane_=plane;}
                void set_actor(vtkActor * actor) {actor_=actor;}
                virtual void Execute(vtkObject *caller, unsigned long, void*)
                {
                        vtkPlaneWidget *  widget = reinterpret_cast<vtkPlaneWidget *>(caller);
                        widget->GetPlane(plane_);
                        actor_->VisibilityOn();
                }
        private:
                vtkPlane * plane_;
                vtkActor *  actor_;
};
//---------------------------------------------------------------------------
a_canvas::a_canvas()
{
        name_ = "a_canvas";
        ren_ = vtkRenderer::New();
        renWin_ = vtkRenderWindow::New();
        renWin_->AddRenderer(ren_);
        ren_->Delete();
        renWin_->SetStereoTypeToAnaglyph();
        renWin_->SetWindowName(name_.c_str());
        renWin_->LineSmoothingOn();
        renWin_->SetSize(640,480);
        active_element_ = 0;
        a_interactor * style = a_interactor::New();
        style->name("a_canvas");
        style->keep_color();
        iren_ = vtkRenderWindowInteractor::New();
        iren_->SetRenderWindow(renWin_);
        iren_->SetInteractorStyle(style);
        iren_->Initialize();
        //testcallback * cb = testcallback::New();
        //cb->iren(iren_);
        //iren_->AddObserver(vtkCommand::TimerEvent, cb);
        //iren_->CreateTimer(VTKI_TIMER_FIRST);
        empty_ = true;
        one_point_ = false;
        spotlight_ = true;
        clip_[0] = 0.1; clip_[1] = 1000;
        magnification_ = 1.;
        log_.file("a_canvas.log");
        log_.on();
        log_ << "#!/usr/bin/env tclsh" << std::endl;
        log_ << "package require a_canvas" << std::endl;
        log_ << "a_canvas window_name" << std::endl;
}
//---------------------------------------------------------------------------
a_canvas::~a_canvas()
{
        //empty content
        this->clear();
        //empty container
        this->reset_interact();
        ren_->Delete();
        renWin_->Delete();  // gives problems
        //      if (iren_) iren_->Delete(); //only if interact() was issued!
        log_ << "rename window_name \"\"" << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::clear()
{
        delete_vector(elements_);
        log_ << "window_name clear" << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::name(const std::string& name)
{
        name_ = name;
        renWin_->SetWindowName(name_.c_str());
        a_interactor * style = (a_interactor *)(iren_->GetInteractorStyle());
        style->name(name_);
        renWin_->Render();
}
//---------------------------------------------------------------------------
void a_canvas::logfile(a_text& text)
{
        log_ << "setlogfile" << std::endl;
        log_ = text;
}
//---------------------------------------------------------------------------
void a_canvas::outputfile(a_text& text)
{
        log_ << "setoutputfile" << std::endl;
        output_ = text;
}
//---------------------------------------------------------------------------
//class used to compute the bounding box of the elements_
class a_bounding_box
{
        public:
                a_bounding_box();
                void operator() (a_element *);
                double m(const char) const;
                double d() const;
                double x() const;
                double y() const;
                double z() const;
        private:
                double l_[6];
};
a_bounding_box::a_bounding_box()
{
        for (int i = 0; i < 3; i++)     l_[i*2] = 1e30;
        for (int i = 0; i < 3; i++)     l_[i*2+1] = -1e30;
}
void a_bounding_box::operator() (a_element * l)
{
        if (!l->empty())
        {
                double b[6];
                l->actor()->GetBounds(b);
                for (int i = 0; i < 3; i++)
                        if (b[i*2]<l_[i*2]) {l_[i*2] = b[i*2];}
                for (int i = 0; i < 3; i++)
                        if (b[i*2+1]>l_[i*2+1]) {l_[i*2+1] = b[i*2+1];}
        }
}
double a_bounding_box::x() const
{
        return l_[1]-l_[0];
}
double a_bounding_box::y() const
{
        return l_[3]-l_[2];
}
double a_bounding_box::z() const
{
        return l_[5]-l_[4];
}
double a_bounding_box::d() const // a reference distance
{
        double d0 = 0;
        for (int i = 0; i < 3; i++)     d0 += (l_[i*2+1]-l_[i*2])*(l_[i*2+1]-l_[i*2]);
        return sqrt(d0);
}
double a_bounding_box::m(const char i) const  // the centre of the object
{
        return (l_[i*2]+l_[i*2+1])/2;
}
//---------------------------------------------------------------------------
bool a_canvas::existelement(const std::string& s) const
{
        for (auto la:elements_)
        {
                std::string name = la->name();
                if (name==s)
                        return true;
        }
        return false;
}
//---------------------------------------------------------------------------
bool a_canvas::existelement(const std::string& s, a_element *& p) const
{
        for (auto la:elements_)
        {
                std::string name = la->name();
                if (name==s)
                {
                        p = la;
                        return true;
                }
 
        }
        return false;
}
//---------------------------------------------------------------------------
void a_canvas::addelement(a_element& la_in)
{
        a_element * p;
        if (!this->existelement(la_in.name(),p)) //if the element doesn't exist yet
        {
                //find the centre of existing points
                double fo[3];
                if (!empty_)
                {
                        a_bounding_box box;
                        //box = std::for_each(elements_.begin(),elements_.end(),box);
                        for (int i =0; i < elements_.size(); i++)
                                box(elements_[i]);
                        for (int i = 0; i < 3; i++)     fo[i] = box.m(i);
                }
                la_in.setcanvas(*this);
                la_in.flushlog();
                active_element_ = &la_in;
                elements_.push_back(&la_in);
                ren_->AddActor(la_in.actor());
                log_ << "window_name object add $" << la_in.name() << std::endl;
                if (!la_in.empty())
                {
                        empty_ = false;
                        renWin_->Render();
                }
        }
}
//---------------------------------------------------------------------------
std::string  a_canvas::listelements()
{
        std::string s;
        for (auto la:elements_)
                s += la->name() + " ";
        if (s.size() != 0)
                s = s.substr(0,s.size()-1);
        log_ << "window_name object ls" << std::endl;
        return s;
}
//---------------------------------------------------------------------------
void a_canvas::setelement(const std::string& s)
{
        a_element * p;
        if (!(this->existelement(s,p))) //if the element doesn't exist yet
                throw no_element_error();
        active_element_ = p;
        log_ << "window_name object set " << s << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::unlinkelement(const std::string& s)
{
        if (active_element_->name() == s) //cannot erase current element
                throw notallowed_error();
        a_element * p;
        if (!this->existelement(s,p)) //if the element doesn't exist yet
                throw no_element_error();
        std::vector<a_element *>::iterator li = std::find(elements_.begin(),elements_.end(),p);
        ren_->RemoveActor(p->actor());
        renWin_->Render();
        elements_.erase(li);
        log_ << "window_name object rm " << s << std::endl;
}
//---------------------------------------------------------------------------
const std::string a_canvas::getelementname() const
{
        return active_element_->name();
}
//---------------------------------------------------------------------------
void a_canvas::fitelements(const std::string & r_mesh, const std::string& r_points)
{
        a_element * mesh, * points;
        if (!this->existelement(r_mesh,mesh)) //if the element doesn't exist yet
                throw no_element_error();
        if (!this->existelement(r_points,points)) //if the element doesn't exist yet
                throw no_element_error();
        std::vector<a_element *>::iterator li = std::find(elements_.begin(),elements_.end(),mesh);
        li = std::find(elements_.begin(),elements_.end(),points);
        if (mesh->type() == "a_trianglecloud")
                throw notallowed_error();
        vtkIterativeClosestPointTransform * transform = vtkIterativeClosestPointTransform::New();
        transform->SetSource(points->polydata());
        transform->SetTarget(mesh->polydata());
        transform->SetMaximumNumberOfIterations(100);
        transform->CheckMeanDistanceOn();
        transform->SetMeanDistanceModeToRMS();
        transform->SetMaximumMeanDistance(0.01);
}
//---------------------------------------------------------------------------
void a_canvas::spotlight()
{
        if (empty_) return;
        spotlight_ = true;
        setlightoncameraposition();
        ren_->LightFollowCameraOn();
        if (iren_)
                iren_->LightFollowCameraOn();
        renWin_->Render();
        log_ << "window_name light spot" << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::sunlight()
{
        if (empty_) return;
        spotlight_ = false;
        setlightoncameraposition();
        ren_->LightFollowCameraOff();
        if (iren_)
                iren_->LightFollowCameraOff();
        renWin_->Render();
        //this->output_position();
        log_ << "window_name light sun" << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::parallel_view()
{
        if (empty_) return;
        ren_->GetActiveCamera()->ParallelProjectionOn();
        renWin_->Render();
        log_ << "window_name perspective off" << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::perspectia_view()
{
        if (empty_) return;
        ren_->GetActiveCamera()->ParallelProjectionOff();
        renWin_->Render();
        log_ << "window_name perspective on" << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::magnification(unsigned short val)
{
        a_interactor * style = (a_interactor *)(iren_->GetInteractorStyle());
        style->magnification(val);
        magnification_ = val;
        log_ << "window_name magnification " << val << std::endl;
}
//---------------------------------------------------------------------------
double a_canvas::scale() const
{
        double h = ren_->GetSize()[1];
        double s = ren_->GetActiveCamera()->GetParallelScale();
        if (s!=0.)
                s = (magnification_*(h/2.))/s;
        return s;
}
//---------------------------------------------------------------------------
void a_canvas::scale(double val)
{
        renWin_->Render();
        double h = ren_->GetSize()[1];
        double s = (h/2.)*(magnification_/val);
        ren_->GetActiveCamera()->SetParallelScale(s);
        renWin_->Render();
        log_ << "window_name scale " << val << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::straighten()
{
        vtkCamera * cam = ren_->GetActiveCamera();
        a_point c(cam->GetPosition());
        a_point f(cam->GetFocalPoint());
        a_point dir = f-c;
        this->unroll();
        if (spotlight_) setlightoncameraposition();
        this->render_clip();
}
//---------------------------------------------------------------------------
void a_canvas::reset_interact()
{
        int n_actors = elements_.size();
        int n_total = ren_->GetActors()->GetNumberOfItems();
        for (int i=0;i<n_total-n_actors;i++)
        {
                vtkActor * actor = ren_->GetActors()->GetLastActor();
                ren_->RemoveActor(actor);
                std::cout << ".";
        }
        std::cout << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::fit_interact()
{
        if (empty_) return;
        vtkBoxWidget * boxWidget = vtkBoxWidget::New();
        boxWidget->SetInteractor(iren_);
        boxWidget->SetPlaceFactor(1.25);
        boxWidget->SetProp3D(active_element_->actor());
        boxWidget->PlaceWidget();
        boxWidget->ScalingEnabledOff();
        boxWidget->OutlineFaceWiresOff();
        boxWidget->HandlesOff();
        deformcallback *callback = deformcallback::New();
        boxWidget->AddObserver(vtkCommand::InteractionEvent, callback);
        boxWidget->On();
        iren_->Start();
        boxWidget->RemoveObserver(callback);
        boxWidget->Delete();
        this->reset_interact();
}
//---------------------------------------------------------------------------
void a_canvas::fit_deform_interact()
{
        if (empty_) return;
        vtkBoxWidget * boxWidget = vtkBoxWidget::New();
        boxWidget->SetInteractor(iren_);
        boxWidget->SetPlaceFactor(1.25);
        boxWidget->SetProp3D(active_element_->actor());
        boxWidget->PlaceWidget();
        deformcallback *callback = deformcallback::New();
        boxWidget->AddObserver(vtkCommand::InteractionEvent, callback);
        boxWidget->On();
        iren_->Start();
        boxWidget->RemoveObserver(callback);
        boxWidget->Delete();
        this->reset_interact();
}
//---------------------------------------------------------------------------
void a_canvas::cut_interact()
{
        if (empty_) return;
        vtkPlaneWidget *  Widget = vtkPlaneWidget::New();
        Widget->SetInteractor(iren_);
        Widget->SetRepresentationToSurface();
        Widget->SetPlaceFactor(1.25);
        Widget->SetProp3D(active_element_->actor());
        Widget->PlaceWidget();
        Widget->GetPlaneProperty()->SetOpacity(.3);
        Widget->GetSelectedPlaneProperty()->SetColor(0.9,0.9,0.9);
        vtkPlane * plane = vtkPlane::New();
        Widget->GetPlane(plane);
        active_element_->actor()->GetMapper()->AddClippingPlane(plane);
        cutcallback * callback = cutcallback::New();
        callback->set_plane(plane);
        callback->set_actor(active_element_->actor());
        Widget->AddObserver(vtkCommand::InteractionEvent, callback);
        Widget->On();
        iren_->Start();
        active_element_->actor()->GetMapper()->RemoveAllClippingPlanes();
        plane->Delete();
        Widget->RemoveObserver(callback);
        //      callback->Delete();
        Widget->Delete();
        this->reset_interact();
}
//---------------------------------------------------------------------------
/*
         void a_canvas::cut_interact2()
         {
         if (empty_) return;
         vtkPolyData * data = vtkPolyData::New();
         data->DeepCopy(active_element_->polydata());
         vtkPlaneWidget *  Widget = vtkPlaneWidget::New();
         Widget->SetInteractor(iren_);
         Widget->SetRepresentationToSurface();
         Widget->SetPlaceFactor(1.25);
         Widget->SetProp3D(active_element_->actor());
         Widget->PlaceWidget();
         vtkPlane * plane = vtkPlane::New();
         Widget->GetPlane(plane);
         vtkClipPolyData * clip = vtkClipPolyData::New();
         clip->SetInput(data);
         plane->Delete();
         vtkPolyDataMapper * map = vtkPolyDataMapper::New();
         map->SetInput(clip->GetOutput());
         vtkActor * cut = vtkActor::New();
         cut->SetMapper(map);
         cut->GetProperty()->SetColor(.5,.5,.7);
         ren_->AddActor(cut);
         cutcallback * callback = cutcallback::New();
         callback->set_plane(plane);
         callback->set_actor(cut);
         callback->set_map(map);
         Widget->AddObserver(vtkCommand::InteractionEvent, callback);
         Widget->On();
         iren_->Start();
         ren_->RemoveActor(cut);
         this->reset_interact();
         }
         */
//---------------------------------------------------------------------------
void a_canvas::interact()
{
        if (empty_) return;
        iren_->Start();
        this->reset_interact();
        /*
        //      iren_->Initialize();
        //      iren_->Enable();
        if (iren_==0)
        {
        std::cerr << "interactor started" << std::endl;
        //              view_pt_interactor * style = view_pt_interactor::New();
        vtkInteractorStyleTrackballCamera * style = vtkInteractorStyleTrackballCamera::New();
        iren_ =  vtkRenderWindowInteractor::New();
        iren_->SetRenderWindow(renWin_);
        //                      renWin_->Delete();
        iren_->SetInteractorStyle(style);
        //                      iren_->Initialize();
        std::cerr << iren_->GetRenderWindow() << std::endl;
        std::cerr << renWin_ << std::endl;
        iren_->Start();
        //              iren_ = vtkRenderWindowInteractor::New();
        //iren_ = vtkXRenderWindowTclInteractor::New();
        //                      iren_->SetRenderWindow(renWin_);
        //                      renWin_->MakeCurrent();
        //                      style->Delete();
        //                      iren_->Initialize();
        //                      std::cerr << "interactor on... " << iren_->GetInitialized() << std::endl;
        //                      iren_->Start();
        //                      iren_->Enable();
        //                      iren_->ReInitialize();
        //                      iren_->Render();
        //                      std::cerr << "+++" << std::endl;
        //              if (!spotlight_) iren_->LightFollowCameraOff();
        //              std::cerr << *iren_ << std::endl;
        }
        */
}
//---------------------------------------------------------------------------
double a_canvas::azimuth() const
{
        double el = this->elevation();
        if ((fabs(el-90.)<very_small)||(fabs(el+90.)<very_small))
                return 90.-ren_->GetActiveCamera()->GetRoll();
        else
        {
                vtkCamera * cam = ren_->GetActiveCamera();
                a_point c(cam->GetPosition());
                a_point f(cam->GetFocalPoint());
                a_point dir = f-c;
                return atan2(dir.y(),dir.x())*r2d;
        }
}
//---------------------------------------------------------------------------
void a_canvas::azimuth(double x)
{
        this->unroll();
        vtkCamera * cam = ren_->GetActiveCamera();
        double el = this->elevation();
        if ((fabs(el-90.)<very_small)||(fabs(el+90.)<very_small))
        {
                x /= 2.;
                cam->SetViewUp(cos(x*d2r),sin(x*d2r),0.);
                this->roll(x);
        }
        else
        {
                a_point c(cam->GetPosition());
                a_point f(cam->GetFocalPoint());
                a_point dir = f-c;
                double d = dir.norm();
                double dz = dir.z();
                double dh = sqrt(d*d-dz*dz);
                a_point dir2(dh*cos(x*d2r),dh*sin(x*d2r),dz);
                a_point c2 = f-dir2;
                cam->SetPosition(c2.x(),c2.y(),c2.z());
                if (spotlight_) setlightoncameraposition();
                this->render_clip();
        }
}
//---------------------------------------------------------------------------
double a_canvas::elevation() const
{
        vtkCamera * cam = ren_->GetActiveCamera();
        a_point c(cam->GetPosition());
        a_point f(cam->GetFocalPoint());
        a_point dir = f-c;
        a_point vert(0.,0.,-1.);
        return angle(vert,dir)*r2d-90.;
}
//---------------------------------------------------------------------------
void a_canvas::elevation(double y)
{
        double az = this->azimuth();
        this->unroll();
        vtkCamera * cam = ren_->GetActiveCamera();
        a_point c(cam->GetPosition());
        a_point f(cam->GetFocalPoint());
        a_point dir = f-c;
        a_point dirh(cos(az*d2r),sin(az*d2r),0.);
        dirh.normalise();
        double d = dir.norm();
        double dz = d*sin(y*d2r);
        double dh = d*cos(y*d2r);
        a_point dir2(dirh.x()*dh,dirh.y()*dh,dz);
        a_point c2 = f-dir2;
        cam->SetPosition(c2.x(),c2.y(),c2.z());
        if (spotlight_) setlightoncameraposition();
        this->render_clip();
}
//---------------------------------------------------------------------------
double a_canvas::roll() const
{
        double el = this->elevation();
        if ((fabs(el-90.)<very_small)||(fabs(el+90.)<very_small))
                return 0.;
        else
                return ren_->GetActiveCamera()->GetRoll();
}
//---------------------------------------------------------------------------
void a_canvas::roll(double z)
{
        /*double el = this->elevation();
                if ((fabs(el-90.)<very_small)||(fabs(el+90.)<very_small))
                return;
                */
        ren_->GetActiveCamera()->Roll(-z);
        this->render_clip();
}
//---------------------------------------------------------------------------
void a_canvas::yaw(double x)
{
        this->unroll();
        vtkCamera * cam = ren_->GetActiveCamera();
        a_point c(cam->GetPosition());
        a_point f(cam->GetFocalPoint());
        a_point dir = f-c;
        double d = dir.norm();
        double dz = dir.z();
        double dh = sqrt(d*d-dz*dz);
        a_point dir2(dh*cos(x*d2r),dh*sin(x*d2r),dz);
        a_point f2 = c+dir2;
        cam->SetFocalPoint(f2.x(),f2.y(),f2.z());
        if (spotlight_) setlightoncameraposition();
        this->render_clip();
}
//---------------------------------------------------------------------------
void a_canvas::pitch(double y)
{
        this->unroll();
        vtkCamera * cam = ren_->GetActiveCamera();
        a_point c(cam->GetPosition());
        a_point f(cam->GetFocalPoint());
        a_point dir = f-c;
        double d = dir.norm();
        double az = this->azimuth();
        a_point dirh(cos(az*d2r),sin(az*d2r),0.);
        dirh.normalise();
        double dz = d*sin(y*d2r);
        double dh = d*cos(y*d2r);
        a_point dir2(dirh.x()*dh,dirh.y()*dh,dz);
        a_point f2 = c+dir2;
        cam->SetFocalPoint(f2.x(),f2.y(),f2.z());
        if (spotlight_) setlightoncameraposition();
        this->render_clip();
}
//---------------------------------------------------------------------------
void a_canvas::unroll()
{
        double el = this->elevation();
        if ((fabs(el-90.)<very_small)||(fabs(el+90.)<very_small))
                return;
        ren_->GetActiveCamera()->Roll(0.);
        this->up(a_point(0.,0.,1.));
}
//---------------------------------------------------------------------------
void a_canvas::distance(double d)
{
        a_point fop = this->focalpoint();
        a_point pop = this->viewpoint();
        a_point pop2 = d*(pop-fop).normalise();
        this->viewpoint(fop+pop2);
        this->render_clip();
}
//---------------------------------------------------------------------------
double a_canvas::distance() const
{
        a_point fop = this->focalpoint();
        a_point pop = this->viewpoint();
        return (fop-pop).norm();
}
//---------------------------------------------------------------------------
void a_canvas::distance0(double v)
{
        a_bounding_box box;
        for (int i =0; i < elements_.size(); i++)
                box(elements_[i]);
        //      box = std::for_each(elements_.begin(),elements_.end(),box);
        double d0 = box.d();
        double d = 2*d0*exp(log(10.)*v/100.);
        this->distance(d);
}
//---------------------------------------------------------------------------
void a_canvas::background(double R, double G, double B)
{
        if (R>=0. && R<=1. && G>=0. && G<=1. && B>=0. && B<=1.)
        {
                ren_->SetBackground(R,G,B);
                renWin_->Render();
        }
}
//---------------------------------------------------------------------------
void a_canvas::x()
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double po[3], fo[3];
        cam->GetPosition(po);
        cam->GetFocalPoint(fo);
        a_point p_po(po);
        a_point p_fo(fo);
        a_point dir(1.,0.,0.);
        double dist = (p_fo-p_po).norm();
        a_point np_po = p_fo-dir*dist;
        cam->SetPosition(np_po.x(),np_po.y(),np_po.z());
        cam->SetViewUp(0.,0.,1.);
        renWin_->Render();
}
//---------------------------------------------------------------------------
void a_canvas::X()
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double po[3], fo[3];
        cam->GetPosition(po);
        cam->GetFocalPoint(fo);
        a_point p_po(po);
        a_point p_fo(fo);
        a_point dir(-1.,0.,0.);
        double dist = (p_fo-p_po).norm();
        a_point np_po = p_fo-dir*dist;
        cam->SetPosition(np_po.x(),np_po.y(),np_po.z());
        cam->SetViewUp(0.,0.,1.);
        renWin_->Render();
}
//---------------------------------------------------------------------------
void a_canvas::y()
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double po[3], fo[3];
        cam->GetPosition(po);
        cam->GetFocalPoint(fo);
        a_point p_po(po);
        a_point p_fo(fo);
        a_point dir(0.,1.,0.);
        double dist = (p_fo-p_po).norm();
        a_point np_po = p_fo-dir*dist;
        cam->SetPosition(np_po.x(),np_po.y(),np_po.z());
        cam->SetViewUp(0.,0.,1.);
        renWin_->Render();
}
//---------------------------------------------------------------------------
void a_canvas::Y()
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double po[3], fo[3];
        cam->GetPosition(po);
        cam->GetFocalPoint(fo);
        a_point p_po(po);
        a_point p_fo(fo);
        a_point dir(0.,-1.,0.);
        double dist = (p_fo-p_po).norm();
        a_point np_po = p_fo-dir*dist;
        cam->SetPosition(np_po.x(),np_po.y(),np_po.z());
        cam->SetViewUp(0.,0.,1.);
        renWin_->Render();
}
//---------------------------------------------------------------------------
void a_canvas::z()
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double po[3], fo[3];
        cam->GetPosition(po);
        cam->GetFocalPoint(fo);
        a_point p_po(po);
        a_point p_fo(fo);
        a_point dir(0.,0.,1.);
        double dist = (p_fo-p_po).norm();
        a_point np_po = p_fo-dir*dist;
        cam->SetPosition(np_po.x(),np_po.y(),np_po.z());
        cam->SetViewUp(1.,0.,0.);
        renWin_->Render();
}
//---------------------------------------------------------------------------
void a_canvas::Z()
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double po[3], fo[3];
        cam->GetPosition(po);
        cam->GetFocalPoint(fo);
        a_point p_po(po);
        a_point p_fo(fo);
        a_point dir(0.,0.,-1.);
        double dist = (p_fo-p_po).norm();
        a_point np_po = p_fo-dir*dist;
        cam->SetPosition(np_po.x(),np_po.y(),np_po.z());
        cam->SetViewUp(1.,0.,0.);
        renWin_->Render();
}
//---------------------------------------------------------------------------
int a_canvas::width() const
{
        return ren_->GetSize()[0];
}
//
//---------------------------------------------------------------------------
int a_canvas::height() const
{
        return ren_->GetSize()[1];
}
//---------------------------------------------------------------------------
void a_canvas::output_position()
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double pt[3];
        cam->GetFocalPoint(pt);
        log_ << "window_name focalpoint " << pt[0] << " " <<  pt[1] << " " <<  pt[2] << std::endl;
        cam->GetPosition(pt);
        log_ << "window_name viewpoint " << pt[0] << " " <<  pt[1] << " " <<  pt[2] << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::pan(const double * pt)
{
        a_point move(pt);
        if (move.norm() > very_small)
        {
                a_point vn = this->viewpoint()+move;
                a_point fn = this->focalpoint()+move;
                double vna[] = {vn.x(), vn.y(), vn.z()};
                double fna[] = {fn.x(), fn.y(), fn.z()};
                this->viewpoint(vna);
                this->focalpoint(fna);
        }
}
//---------------------------------------------------------------------------
a_point a_canvas::viewpoint() const
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double po[3];
        cam->GetPosition(po);
        return a_point(po);
}
//---------------------------------------------------------------------------
a_point a_canvas::focalpoint() const
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double fp[3];
        cam->GetFocalPoint(fp);
        return a_point(fp);
}
//---------------------------------------------------------------------------
a_point a_canvas::up() const
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double up[3];
        cam->GetViewUp(up);
        return a_point(up);
}
//---------------------------------------------------------------------------
void a_canvas::viewpoint(const a_point& c)
{
        vtkCamera * cam = ren_->GetActiveCamera();
        a_point f(cam->GetFocalPoint());
        a_point dir = f-c;
        //view and focal points cannot coincide
        if (dir.norm() > very_small)
        {
                cam->SetPosition(c.x(),c.y(),c.z());
                if (spotlight_) setlightoncameraposition();
                this->render_clip();
        }
}
//---------------------------------------------------------------------------
void a_canvas::focalpoint(const a_point& f)
{
 
        vtkCamera * cam = ren_->GetActiveCamera();
        a_point c(cam->GetPosition());
        a_point dir = f-c;
        //view and focal points cannot coincide
        if (dir.norm() > very_small)
        {
                //      this->unroll();
                cam->SetFocalPoint(f.x(),f.y(),f.z());
                if (spotlight_) setlightoncameraposition();
                this->render_clip();
        }
}
//---------------------------------------------------------------------------
void a_canvas::up(const a_point& p)
{
        a_point p2 = p;
        if (p.norm() > very_small)
        {
                p2.normalise();
                vtkCamera * cam = ren_->GetActiveCamera();
                cam->SetViewUp(p2.x(),p2.y(),p2.z());
                if (spotlight_) setlightoncameraposition();
                this->render_clip();
        }
}
//---------------------------------------------------------------------------
void a_canvas::viewpoint(const double * pt)
{
        this->viewpoint(a_point(pt[0],pt[1],pt[2]));
}
//---------------------------------------------------------------------------
void a_canvas::focalpoint(const double * pt)
{
        this->focalpoint(a_point(pt[0],pt[1],pt[2]));
}
//---------------------------------------------------------------------------
void a_canvas::up(const double * pt)
{
        this->up(a_point(pt[0],pt[1],pt[2]));
}
//---------------------------------------------------------------------------
void a_canvas::jpgout(const std::string& file)
{
        std::string f0 = file.substr(0,file.find_first_of('.'))+".jpg";
        vtkRenderLargeImage * grab = vtkRenderLargeImage::New();
        grab->SetInput(ren_);
        grab->SetMagnification(magnification_);
        vtkJPEGWriter * writer = vtkJPEGWriter::New();
        writer->SetFileName(const_cast<char *>(f0.c_str()));
        writer->SetInputConnection(grab->GetOutputPort());
        writer->SetQuality(100);//between 0 and 100
        grab->Delete();
        writer->Write();
        writer->Delete();
        this->output_position();
        log_ << "window_name save jpg " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::pngout(const std::string& file)
{
        std::string f0 = file.substr(0,file.find_first_of('.'))+".png";
        vtkRenderLargeImage * grab = vtkRenderLargeImage::New();
        grab->SetInput(ren_);
        grab->SetMagnification(magnification_);
        vtkPNGWriter * writer = vtkPNGWriter::New();
        writer->SetFileName(const_cast<char *>(f0.c_str()));
        writer->SetInputConnection(grab->GetOutputPort());
        grab->Delete();
        writer->Write();
        writer->Delete();
        this->output_position();
        log_ << "window_name save png " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::vrmlout(const std::string& file)
{
        vtkVRMLExporter * writer = vtkVRMLExporter::New();
        writer->SetFileName(file.c_str());
        writer->SetInput(renWin_);
        writer->Write();
        writer->Delete();
        log_ << "window_name save vrml " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::vtkout(const std::string& file)
{
        vtkAppendPolyData * datas = vtkAppendPolyData::New();
        for (auto la:elements_)
                datas->AddInputData(la->polydata());
        vtkPolyDataWriter * writer = vtkPolyDataWriter::New();
        writer->SetFileName(file.c_str());
        writer->SetInputConnection(datas->GetOutputPort());
        datas->Delete();
        writer->Write();
        writer->Delete();
        log_ << "window_name save vtk " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::ribout(const std::string& file)
{
        std::string f0 = file.substr(0,file.find_first_of('.'));
        vtkRIBExporter * writer = vtkRIBExporter::New();
        writer->SetFilePrefix(f0.c_str());
        writer->SetInput(renWin_);
        writer->Write();
        writer->Delete();
        this->output_position();
        log_ << "window_name save rib " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::tifout(const std::string& file)
{
        std::string f0 = file.substr(0,file.find_first_of('.'))+".tif";
        vtkWindowToImageFilter * grab = vtkWindowToImageFilter::New();
        grab->SetInput(renWin_);
        vtkTIFFWriter * writer = vtkTIFFWriter::New();
        writer->SetFileName(const_cast<char *>(f0.c_str()));
        writer->SetInputConnection(grab->GetOutputPort());
        grab->Delete();
        writer->Write();
        writer->Delete();
        this->output_position();
        log_ << "window_name save tiff " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_canvas::render_clip()
{
        ren_->GetActiveCamera()->SetClippingRange(clip_[0],clip_[1]);
        renWin_->Render();
}
//---------------------------------------------------------------------------
void a_canvas::reset()
{
        a_bounding_box box;
        for (int i =0; i < elements_.size(); i++)
                box(elements_[i]);
        //      box = std::for_each(elements_.begin(),elements_.end(),box);
        double fo[3];
        for (int i = 0; i < 3; i++)     fo[i] = box.m(i);
        double d0 = box.d();
        vtkCamera * cam = ren_->GetActiveCamera();
        //active for parallel projection
        cam->SetParallelScale(box.z());
        //active for perspective
        cam->SetFocalPoint(fo);
        cam->SetPosition(fo[0],fo[1]-2*d0,fo[2]);
        cam->ComputeViewPlaneNormal();
        cam->SetViewAngle(30);
        cam->SetViewUp(0,0,1);
        this->render_clip();
        this->spotlight();
}
//---------------------------------------------------------------------------
void a_canvas::setlightoncameraposition()
{
        double po[3], fo[3];
        vtkCamera * cam = ren_->GetActiveCamera();
        cam->GetPosition(po);
        cam->GetFocalPoint(fo);
        vtkLightCollection * lights = ren_->GetLights();
        lights->InitTraversal();
        vtkLight * light = lights->GetNextItem();
        light->SetPosition(po);
        light->SetFocalPoint(fo);
        light->SetIntensity(1);
}
//*input/output*************************************************
//-operator>>----------------------------------------------------------------
std::istream& operator>> (std::istream& i, a_canvas& w)
{
        return i;
}
//-operator<<----------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, a_canvas& w)
{
        o << w.elements_.size() << std::endl;
        for (auto la:w.elements_)
                o << *la;
        return o;
}
//---------------------------------------------------------------------------
void a_canvas::open(const std::string& file)
{
        std::ifstream ff(file.c_str());
        if (ff) 
        {
                ff >> *this;
                renWin_->Render();
                log_ << "window_name open " << file << std::endl;
        }
}
//---------------------------------------------------------------------------
void a_canvas::save(const std::string& file)
{
        std::ofstream ff(file.c_str());
        if (ff)
        {
                ff << *this;
                log_ << "window_name save " << file << std::endl;
        }
}