a_screen.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 "vtkActor.h"
#include "vtkAppendPolyData.h"
#include "vtkCamera.h"
#include "vtkCellArray.h"
#include "vtkDataSetMapper.h"
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkJPEGWriter.h"
#include "vtkLight.h"
#include "vtkLightCollection.h"
#include "vtkPoints.h"
#include "vtkPolyDataWriter.h"
#include "vtkRenderLargeImage.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRIBExporter.h"
#include "vtkTIFFWriter.h"
#include "vtkPNGWriter.h"
#include "vtkVRMLExporter.h"
#include "vtkWindowToImageFilter.h"
// #include "vtkXRenderWindowTclInteractor.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_screen.h"
 
//---------------------------------------------------------------------------
const std::string a_screen::help()
{
        std::ostringstream o;
        o << "**********" << std::endl;
        o << "a_screen:" << std::endl;
        o << "**********" << std::endl;
        o << "This is a 3D window class" << std::endl;
        o << "Commands:" << std::endl;
        o << "--------" << std::endl;
        o << "a_screen W: create a window" << std::endl;
        o << "Drawing:" << std::endl;
        o << "......." << std::endl;
        o << "point X Y Z: draw a point." << std::endl;
        o << "line X1 Y1 Z1 X2 Y2 Z2: draw a line." << std::endl;
        o << "vertex X Y Z: draw point of a polyline." << std::endl;
        o << "endpolyline: end the polyline." << std::endl;
        o << "closepolyline: link the last vertex with the first vertex." << std::endl;
        o << "surfacepoint X Y Z: add a point to a surface (1 surface per layer)." << std::endl;
        o << "......." << std::endl;
        o << "erase point: erase last point." << std::endl;
        o << "erase line: erase last line." << std::endl;
        o << "erase polyline: erase last polyline." << std::endl;
        o << "Layer management:" << std::endl;
        o << "................" << std::endl;
        o << "the default layer is '0'" << std::endl;
        o << "layer new NAME: create new layer" << std::endl;
        o << "layer set NAME: set current layer" << std::endl;
        o << "layer on NAME: make layer visible" << std::endl;
        o << "layer off NAME: hide layer" << std::endl;
        o << "layer erase NAME: erase layer" << std::endl;
        o << "(alternatively: layer rm NAME)" << std::endl;
        o << "layer list: return a list of existing layers" << std::endl;
        o << "(alternatively: layer ls)" << std::endl;
        o << "layer current: return name of current layer" << std::endl;
        o << "layer exist NAME: check whether layer exists (returns 0 or 1)" << std::endl;
        o << "color R G B: set color of current layer" << std::endl;
        o << "R: get the red component of current layer" << std::endl;
        o << "G: get the green component of current layer" << std::endl;
        o << "B: get the blue component of current layer" << std::endl;
        o << "thickness T: set thickness of lines in currrent layer" << std::endl;
        o << "thickness: get thickness of lines in currrent layer" << 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 << "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 << "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 << "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 << "import CODE FILE: import data" << std::endl;
        o << "(code: pt, dxf)" << std::endl;
        o << "save CODE FILE" << std::endl;
        o << "(code: pt, dxf, jpeg, rib, png, vec, vrml, vtk)" << std::endl;
        o << "logfile VE_TEXT: log is saved to a a_text object" << std::endl;
        o << "outputfile VE_TEXT: output is saved to a a_text object" << std::endl;
        o << "VE_TEXT should be created before: ex: a_text NAME" << std::endl;
        return o.str();
}
//---------------------------------------------------------------------------
a_screen::a_screen()
        //a_screen::a_screen(const std::string& id)
{
        //      std::string id2(id);
        //      const char * id2 = id.c_str();
        //      std::istringstream in(id);
        //      int w_id;
        //      in >> w_id;
        //      std::cerr << "{" << w_id << "}" << std::endl;
        ren_ = vtkRenderer::New();
        renWin_ = vtkRenderWindow::New();
        renWin_->AddRenderer(ren_);
        //renWin_->SetParentId(w_id);
        //              renWin_->SetParentInfo(id.c_str());
        //              renWin_->SetParentInfo(id2.c_str());
        //              renWin_->SetParentId((void *)w_id);
        //              ren_->Delete();
        renWin_->SetStereoTypeToAnaglyph();
        renWin_->SetSize(640,480);
        newlayer(std::string("0")); //the basis' layer name: cf. AutoCad
        active_layer_ = *(layers_.begin());
        ren_->AddActor(active_layer_->actor());
        ren_->AddActor(active_layer_->actor2());
        //      this->line(0,0,0,1,0,0);
        //      this->line(0,0,0,0,1,0);
        //      this->line(0,0,0,0,0,1);
        //      iren_ = 0;
        //        iren_ = vtkRenderWindowInteractor::New();
        //      iren_->SetRenderWindow(renWin_);
        //      iren_->Start();
 
        a_interactor * style = a_interactor::New();
        style->name("screen");
        style->keep_color();
        iren_ = vtkRenderWindowInteractor::New();
        iren_->SetRenderWindow(renWin_);
        iren_->SetInteractorStyle(style);
        iren_->Initialize();
        //              iren_->Disable();
        empty_ = true;
        one_point_ = false;
        x0_ = 0; y0_ = 0; z0_ = 0;
        spotlight_ = true;
        clip_[0] = 0.1; clip_[1] = 1000;
        renWin_->SetWindowName("screen"); 
        log_.file("a_screen.log");
        log_.on();
        log_ << "#!/usr/bin/env tclsh" << std::endl;
        log_ << "package require a_screen" << std::endl;
        log_ << "a_screen window_name" << std::endl;
 
}
//---------------------------------------------------------------------------
a_screen::~a_screen()
{
        delete_vector(layers_);
        ren_->Delete();
        renWin_->Delete();  // gives problems
        if (iren_) iren_->Delete(); //only if interact() was issued!
        log_ << "rename window_name \"\"" << std::endl;
}
//---------------------------------------------------------------------------
//class used to compute the bounding box of the layers_
class a_bounding_box
{
        public:
                a_bounding_box();
                void operator() (a_screenlayer *);
                double m(const char) const;
                double d() 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_screenlayer * 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::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_screen::existlayer(const std::string& s) const
{
        for (auto la:layers_)
        {
                if (*la==s)
                        return true;
        }
        return false;
}
//---------------------------------------------------------------------------
bool a_screen::existlayer(const std::string& s, a_screenlayer *& p) const
{
        for (auto la:layers_)
        {
                if (*la==s)
                {
                        p = la;
                        return true;
                }
        }
        return false;
}
//---------------------------------------------------------------------------
void a_screen::newlayer(const std::string& s)
{
        if (!this->existlayer(s)) //if the layer doesn't exist yet
        {
                //find the center of existing points
                double fo[3];
                if (!empty_)
                {
                        a_bounding_box box;
                        // box = std::for_each(layers_.begin(),layers_.end(),box);
                        for (auto la:layers_)
                                box(la);
                        for (int i = 0; i < 3; i++)     fo[i] = box.m(i);
                }
                auto l = new a_screenlayer;
                l->name(s);
                layers_.push_back(l);
                ren_->AddActor(l->actor());
                ren_->AddActor(l->actor2());
                l->reset(); //trick to enable the sequence "newlayer,line,setlayer,line"
                log_ << "window_name newlayer " << s << std::endl;
        }
}
//---------------------------------------------------------------------------
void a_screen::newlayer(const a_screenlayer& la_in)
{
        a_screenlayer * p;
        if (!this->existlayer(la_in.name(),p)) //if the layer doesn't exist yet
        {
                //find the centre of existing points
                double fo[3];
                if (!empty_)
                {
                        a_bounding_box box;
                        //box = std::for_each(layers_.begin(),layers_.end(),box);
                        for (auto la:layers_)
                                box(la);
                        for (int i = 0; i < 3; i++)     fo[i] = box.m(i);
                }
                auto la_out = new a_screenlayer;
                la_out->reset();
                la_out->append(la_in);
                layers_.push_back(la_out);
                ren_->AddActor(la_out->actor());
                ren_->AddActor(la_out->actor2());
        }
        else
                p->append(la_in);
}
//---------------------------------------------------------------------------
std::string  a_screen::listlayers()
{
        std::string s;
        for (auto la:layers_)
                s += la->name() + " ";
        if (s.size() != 0)
                s = s.substr(0,s.size()-1);
        log_ << "window_name listlayers" << std::endl;
        return s;
}
//---------------------------------------------------------------------------
void a_screen::setlayer(const std::string& s)
{
        a_screenlayer * p;
        if (!this->existlayer(s,p)) //if the layer doesn't exist yet
                throw no_layer_error();
        active_layer_ = p;
        log_ << "window_name setlayer " << s << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::eraselayer(const std::string& s)
{
        if (s == "0") //cannot erase basis layer
                throw notallowed_error();
        if (active_layer_->name() == s) //cannot erase current layer
                throw notallowed_error();
        a_screenlayer * p;
        if (!this->existlayer(s,p)) //if the layer doesn't exist yet
                throw no_layer_error();
        std::vector<a_screenlayer *>::iterator li = std::find(layers_.begin(),layers_.end(),p);
        ren_->RemoveActor(p->actor());
        ren_->RemoveActor(p->actor2());
        if (p->hassurface())
                ren_->RemoveActor(p->surfaceactor());
        /*
 
                 SHOULD BE SOLVED       
                 delete p;
                 layers_.erase(&p); new.... */
        layers_.erase(li);
 
        renWin_->Render();
        log_ << "window_name eraselayer " << s << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::setofflayer(const std::string& s)
{
        a_screenlayer * p;
        if (!this->existlayer(s,p)) //if the layer doesn't exist yet
                throw no_layer_error();
        p->visibility(0);
        renWin_->Render();
}
//---------------------------------------------------------------------------
void a_screen::setonlayer(const std::string& s)
{
        a_screenlayer * p;
        if (!this->existlayer(s,p)) //if the layer doesn't exist yet
                throw no_layer_error();
        p->visibility(1);
        renWin_->Render();
}
//---------------------------------------------------------------------------
const std::string a_screen::getlayer() const
{
        return active_layer_->name();
}
//---------------------------------------------------------------------------
void a_screen::color(float r, float g, float b)
{
        active_layer_->color(r,g,b);
        if (!active_layer_->empty())
                renWin_->Render();
        log_ << "window_name color " << r << " " << g << " " << b << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::thickness(const int t)
{
        if ((t<8)&&(t>0))
                active_layer_->thickness(t);
        if (!active_layer_->empty())
                renWin_->Render();
        log_ << "window_name thickness " << t << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::spotlight()
{
        spotlight_ = true;
        setlightoncameraposition();
        ren_->LightFollowCameraOn();
        if (iren_)
                iren_->LightFollowCameraOn();
        renWin_->Render();
        log_ << "window_name light spot" << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::sunlight()
{
        spotlight_ = false;
        setlightoncameraposition();
        ren_->LightFollowCameraOff();
        if (iren_) 
                iren_->LightFollowCameraOff();
        renWin_->Render();
        //this->output_position();
        log_ << "window_name light sun" << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::parallel_view()
{
        ren_->GetActiveCamera()->ParallelProjectionOn();
        renWin_->Render();
        log_ << "window_name perspective off" << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::perspectia_view()
{
        ren_->GetActiveCamera()->ParallelProjectionOff();
        renWin_->Render();
        log_ << "window_name perspective on" << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::interact()
{
        //      iren_->Start();
        //      iren_->Initialize();
        //      iren_->Enable();
        iren_->Start();
        if (iren_==0)
        {
                /*              std::cerr << "interactor started" << std::endl;
                //              view_pt_interactor * style = view_pt_interactor::New();
                //              iren_ =  vtkRenderWindowInteractor::New();
                //                      iren_->SetRenderWindow(renWin_);
                //                      renWin_->Delete();
                //                      iren_->SetInteractorStyle(style);
                //                      iren_->Initialize();
                vtkInteractorStyleTrackballCamera * style = vtkInteractorStyleTrackballCamera::New();
                iren_ = vtkRenderWindowInteractor::New();
                //iren_ = vtkXRenderWindowTclInteractor::New();
                iren_->SetRenderWindow(renWin_);
                //                      renWin_->MakeCurrent();
                iren_->SetInteractorStyle(style);
                //                      style->Delete();
                //                      iren_->Initialize();
                //                      std::cerr << "interactor on... " << iren_->GetInitialized() << std::endl;
                //                      iren_->Start();
                //                      iren_->Enable();
                //                      iren_->ReInitialize();
                //                      iren_->Render();
                //                      std::cerr << iren_->GetRenderWindow() << std::endl;
                //                      std::cerr << renWin_ << std::endl;
                //                      std::cerr << "+++" << std::endl;
                //              if (!spotlight_) iren_->LightFollowCameraOff();
                //              std::cerr << *iren_ << std::endl;
                */      }
}
//---------------------------------------------------------------------------
void a_screen::point(const a_point& p)
{
        this->point(p.x(),p.y(),p.z());
}
//---------------------------------------------------------------------------
void a_screen::point(double x, double y, double z)
{
        active_layer_->point(x,y,z);
        if (empty_)
        {
                if (one_point_)
                {
                        renWin_->Render();
                        renWin_->SetWindowName("screen"); 
                        empty_ = false;
                }
                else
                        one_point_ = true;
        }
        else
                renWin_->Render();
        log_ << "window_name point " << x << " " << y << " " << z << " " << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::line(const a_point& p1, const a_point& p2)
{
        this->line(p1.x(),p1.y(),p1.z(),p2.x(),p2.y(),p2.z());
}
//---------------------------------------------------------------------------
void a_screen::line(double x1, double y1, double z1, double x2, double y2, double z2)
{
        active_layer_->line(x1,y1,z1,x2,y2,z2);
        if (empty_)
        {
                empty_ = false;
                renWin_->Render();
                renWin_->SetWindowName("screen"); 
        }
        else
                renWin_->Render();
        log_ << "window_name line "      << x1 << " " << y1 << " " << z1 << " " 
                << x2 << " " << y2 << " " << z2 << " " << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::vertex(const a_point& p)
{
        this->vertex(p.x(),p.y(),p.z());
}
//---------------------------------------------------------------------------
void a_screen::vertex(double x, double y, double z)
{
        active_layer_->vertex(x,y,z);
        log_ << "window_name vertex " << x << " " << y << " " << z << " " << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::endpolyline()
{
        active_layer_->endpolyline();
        if (empty_)
        {
                empty_ = false;
                renWin_->Render();
                renWin_->SetWindowName("screen"); 
        }
        else
                renWin_->Render();
        log_ << "window_name endpolyline" << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::closepolyline()
{
        active_layer_->closepolyline();
        if (empty_)
        {
                empty_ = false;
                renWin_->Render();
                renWin_->SetWindowName("screen"); 
        }
        else
                renWin_->Render();
        log_ << "window_name closepolyline" << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::point0(double x, double y, double z)
{
        active_layer_->point(x,y,z);
}
//---------------------------------------------------------------------------
void a_screen::line0(double x1, double y1, double z1, double x2, double y2, double z2)
{
        active_layer_->line(x1,y1,z1,x2,y2,z2);
}
//---------------------------------------------------------------------------
void a_screen::vertex0(double x, double y, double z)
{
        active_layer_->vertex(x,y,z);
}
//---------------------------------------------------------------------------
void a_screen::endpolyline0()
{
        active_layer_->endpolyline();
}
//---------------------------------------------------------------------------
void a_screen::closepolyline0()
{
        active_layer_->closepolyline();
}
//---------------------------------------------------------------------------
void a_screen::surfacepoint(const a_point& p)
{
        this->surfacepoint(p.x(),p.y(),p.z());
}
//---------------------------------------------------------------------------
void a_screen::surfacepoint(double x, double y, double z)
{
        active_layer_->surfacepoint(x,y,z);
        if (active_layer_->hassurface())
        {
                if (active_layer_->surfaceready())
                {
                        ren_->AddActor(active_layer_->surfaceactor());
                        if (empty_)
                        {
                                empty_ = false;
                                renWin_->Render();
                                renWin_->SetWindowName("screen"); 
                                return;
                        }
                }
                renWin_->Render();
        }
        log_ << "window_name surfacepoint " << x << " " << y << " " << z << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::eraselastpoint()
{
        active_layer_->eraselastpoint();
        renWin_->Render();
        log_ << "window_name erase point" << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::eraselastline()
{
        active_layer_->eraselastline();
        renWin_->Render();
        log_ << "window_name erase line" << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::eraselastpolyline()
{
        active_layer_->eraselastpolyline();
        renWin_->Render();
        log_ << "window_name erase polylineline" << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::azimuth(double x)
{
        this->unroll();
        ren_->GetActiveCamera()->Azimuth(x0_-x);
        x0_ = x;
        if (spotlight_) setlightoncameraposition();
        this->render_clip();
}
//---------------------------------------------------------------------------
void a_screen::elevation(double y)
{
        this->unroll();
        ren_->GetActiveCamera()->Elevation(y0_-y);
        y0_ = y;
        if (spotlight_) setlightoncameraposition();
        this->render_clip();
}
//---------------------------------------------------------------------------
void a_screen::roll(double z)
{
        ren_->GetActiveCamera()->Roll(z0_-z);
        z0_ = z;
        this->render_clip();
}
//---------------------------------------------------------------------------
void a_screen::pitch(double u)
{
        this->unroll();
        ren_->GetActiveCamera()->Pitch(u-y0_);
        y0_ = u;
        if (spotlight_) setlightoncameraposition();
        this->render_clip();
}
//---------------------------------------------------------------------------
void a_screen::yaw(double v)
{
        this->unroll();
        ren_->GetActiveCamera()->Yaw(x0_-v);
        x0_ = v;
        if (spotlight_) setlightoncameraposition();
        this->render_clip();
}
//---------------------------------------------------------------------------
void a_screen::unroll()
{
        if (z0_ != 0)
        {
                ren_->GetActiveCamera()->Roll(z0_);
                z0_ = 0;
        }
}
//---------------------------------------------------------------------------
void a_screen::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_screen::distance() const
{
        a_point fop = this->focalpoint();
        a_point pop = this->viewpoint();
        return (fop-pop).norm();
}
//---------------------------------------------------------------------------
void a_screen::distance0(double v)
{
        a_bounding_box box;
        for (auto la:layers_)
                box(la);
        //      box = std::for_each(layers_.begin(),layers_.end(),box);
        double d0 = box.d();
        double d = 2*d0*exp(log(10)*v/100);
        this->distance(d);
}
//---------------------------------------------------------------------------
void a_screen::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_screen::output_position()
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double pt[3];
        cam->GetFocalPoint(pt);
        log_ << "window_name setfocalpoint " << pt[0] << " " <<  pt[1] << " " <<  pt[2] << std::endl;
        cam->GetPosition(pt);
        log_ << "window_name setviewpoint " << pt[0] << " " <<  pt[1] << " " <<  pt[2] << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::pan(const double * pt)
{
        a_point move(pt);
        if (move.norm() > 0.00001)
        {
                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_screen::viewpoint() const
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double po[3];
        cam->GetPosition(po);
        return a_point(po);
}
//---------------------------------------------------------------------------
a_point a_screen::focalpoint() const
{
        vtkCamera * cam = ren_->GetActiveCamera();
        double fp[3];
        cam->GetFocalPoint(fp);
        return a_point(fp);
}
//---------------------------------------------------------------------------
void a_screen::viewpoint(const a_point& poo)
{
        vtkCamera * cam = ren_->GetActiveCamera();
        a_point fpo = this->focalpoint();
        //view and focal points cannot coincide
        if ((fpo-poo).norm() > 0.00001)
        {
                this->unroll();
                cam->SetPosition(poo.x(),poo.y(),poo.z());
                cam->ComputeViewPlaneNormal();
                cam->SetViewAngle(30);
                a_point n = (fpo-poo).normalise();
                if ((n.x()>0)||(n.y()>0))
                        cam->SetViewUp(0,0,1);
                else
                        cam->SetViewUp(1,0,0);
                if (spotlight_) setlightoncameraposition();
                this->render_clip();
                if (n.x() != 0)
                        x0_ = (180/3.14159265358979)*atan2(n.y(),n.x());
                else
                {
                        if (n.y()<0)
                                x0_ = -90;
                        else
                                x0_ = 90;
                }
                y0_ = 90-(180/3.14159265358979)*acos(n.z());
        }
}
//---------------------------------------------------------------------------
void a_screen::focalpoint(const a_point& fpo)
{
        vtkCamera * cam = ren_->GetActiveCamera();
        a_point poo = this->viewpoint();
        //view and focal points cannot coincide
        if ((fpo-poo).norm() > 0.00001)
        {
                this->unroll();
                cam->SetFocalPoint(fpo.x(),fpo.y(),fpo.z());
                cam->ComputeViewPlaneNormal();
                cam->SetViewAngle(30);
                a_point n = (fpo-poo).normalise();
                if ((n.x()>0)||(n.y()>0))
                        cam->SetViewUp(0,0,1);
                else
                        cam->SetViewUp(1,0,0);
                if (spotlight_) setlightoncameraposition();
                this->render_clip();
                if (n.x() != 0)
                        x0_ = (180/3.14159265358979)*atan2(n.y(),n.x());
                else
                {
                        if (n.y()<0)
                                x0_ = -90;
                        else
                                x0_ = 90;
                }
                y0_ = 90-(180/3.14159265358979)*acos(n.z());
        }
}
//---------------------------------------------------------------------------
void a_screen::viewpoint(const double * pt)
{
        this->viewpoint(a_point(pt[0],pt[1],pt[2]));
}
//---------------------------------------------------------------------------
void a_screen::focalpoint(const double * pt)
{
        this->focalpoint(a_point(pt[0],pt[1],pt[2]));
}
//---------------------------------------------------------------------------
void a_screen::dxfin(const std::string& file)
{
        std::ifstream   ff(file.c_str());
        if (!ff) throw filenotfound_error();
        a_dxf_group     group(&ff);
        //loop through entitities
        a_dxf_point     point(&ff);
        a_dxf_line              line(&ff);
        a_dxf_polyline polyline(&ff);
        a_dxf_entity   entity(&ff);
        std::string layer0 = "0";
        while (group.read())
        {
                if (group.code() != 0) throw file_error();
                //read entity
                if      (group.data_is("POINT"))
                {
                        if (point.read())
                        {
                                if (point.layer() != layer0)
                                {
                                        layer0 = point.layer();
                                        newlayer(layer0);
                                        setlayer(layer0);
                                }
                                this->point0(point.x(),point.y(),point.z());
                        }
                }
                else if (group.data_is("LINE"))
                {
                        if (line.read())
                        {
                                if (line.layer() != layer0)
                                {
                                        layer0 = line.layer();
                                        newlayer(layer0);
                                        setlayer(layer0);
                                }
                                this->line0(line.x1(),line.y1(),line.z1(),line.x2(),line.y2(),line.z2());
                        }
                }
                else if (group.data_is("POLYLINE"))
                {
                        polyline.init();
                        if (polyline.read())
                        {
                                if (polyline.layer() != layer0)
                                {
                                        layer0 = polyline.layer();
                                        newlayer(layer0);
                                        setlayer(layer0);
                                }
                                for (int i=0; i<polyline.n(); i++)
                                        this->vertex0(polyline.x(i),polyline.y(i),polyline.z(i));
                                this->endpolyline0();
                        }
                }
                else entity.read();
        }
        ff.close();
        if (empty_)
        {
                empty_ = false;
                renWin_->Render();
                renWin_->SetWindowName("screen"); 
        }
        else
                renWin_->Render();
        log_ << "window_name import dxf " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::dxfout(const std::string& file)
{
        std::ofstream o(file.c_str());
        if (!o)
        {
                output_ << "cannot create file '" << file << "'" << std::endl;
                return;
        }
        //header
        o << " 0" << std::endl << "SECTION" << std::endl;
        o << " 2" << std::endl << "ENTITIES" << std::endl;
        //body
        for (auto la:layers_)
        {
                if (la->isvisible())
                        la->dxfout(o);
        }
        //footer
        o << " 0" << std::endl << "ENDSEC" << std::endl;
        o << " 0" << std::endl << "EOF" << std::endl;
        o.close();
        log_ << "window_name save dxf " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::ptin(const std::string& file)
{
        std::ifstream   ff(file.c_str());
        if (!ff) throw filenotfound_error();
        active_layer_->ptin(ff);
        ff.close();
        if (empty_)
        {
                empty_ = false;
                renWin_->Render();
                renWin_->SetWindowName("screen");
        }
        else
                renWin_->Render();
        log_ << "window_name import pt " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::ptout(const std::string& file)
{
        std::ofstream o(file.c_str());
        if (!o)
        {
                output_ << "cannot create file '" << file << "'" << std::endl;
                return;
        }
        active_layer_->ptout(o);
        o.close();
        log_ << "window_name save pt " << file << std::endl;
}
//---------------------------------------------------------------------------
void a_screen::jpgout(const std::string& file)
{
        std::string f0 = file.substr(0,file.find_first_of('.'))+".jpg";
        vtkWindowToImageFilter * grab = vtkWindowToImageFilter::New();
        grab->SetInput(renWin_);
        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_screen::pngout(const std::string& file)
{
        std::string f0 = file.substr(0,file.find_first_of('.'))+".png";
        vtkRenderLargeImage * grab = vtkRenderLargeImage::New();
        grab->SetInput(ren_);
        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_screen::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_screen::vtkout(const std::string& file)
{
        vtkAppendPolyData * datas = vtkAppendPolyData::New();
        for (auto la:layers_)
        {
                datas->AddInputData(la->polydata());
                datas->AddInputData(la->polydata2());
        }
        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_screen::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_screen::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_screen::render_clip()
{
        ren_->GetActiveCamera()->SetClippingRange(clip_[0],clip_[1]);
        renWin_->Render();
}
//---------------------------------------------------------------------------
void a_screen::reset()
{
        a_bounding_box box;
        for (auto la:layers_)
                box(la);
        //      box = std::for_each(layers_.begin(),layers_.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();
        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();
        x0_ = y0_ = z0_ = 0;
}
//---------------------------------------------------------------------------
void a_screen::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_screen& w)
{
        delete_vector(w.layers_);
        int n_layers;
        i >> n_layers;
        a_screenlayer * la0;
        for (int k = 0; k < n_layers; k++)
        {
                auto la = new a_screenlayer;
                la->reset();
                i >> *la;
                if (k==0)
                        la0 = la;
                w.layers_.push_back(la);
                w.ren_->AddActor(la->actor());
                w.ren_->AddActor(la->actor2());
        }
        w.active_layer_ = la0;
        return i;
}
//-operator<<----------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, a_screen& w)
{
        o << w.layers_.size() << std::endl;
        for (auto la:w.layers_)
                o << *la;
        return o;
}
//---------------------------------------------------------------------------
void a_screen::open(const std::string& file)
{
        std::ifstream ff(file.c_str());
        if (ff) 
        {
                ff >> *this;
                renWin_->Render();
                renWin_->SetWindowName("screen"); 
                log_ << "window_name open " << file << std::endl;
        }
}
//---------------------------------------------------------------------------
void a_screen::save(const std::string& file)
{
        std::ofstream ff(file.c_str());
        if (ff)
        {
                ff << *this;
                log_ << "window_name save " << file << std::endl;
        }
}