a_screen.h

Go to the documentation of this file.

/*
         Copyright 2010-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/>.
         */
#ifndef _A_SCREEN_H_
#define _A_SCREEN_H_
 
// .NAME a_screen 
// .PORTABILITY : ansi C++
// .SECTION Author
// Pierre Smars
 
#include "vtkPolyData.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
 
#include "a_screenlayer.h"
#include "a_text.h"
#include "a_point.h"
 
#include <string>
#include <vector>
 
class a_screen
{
        public:
                //      a_screen(const std::string& id);
                a_screen();
                ~a_screen();
                virtual std::string type() const {return "a_screen";}
                inline void logfile(a_text& text) {log_ << "setlogfile" << std::endl; log_ = text;}
                inline void outputfile(a_text& text) {log_ << "setoutputfile" << std::endl; output_ = text;}
                //      inline void logfile(a_text& text) {this->logfile() << "setlogfile" << std::endl; log_ = text;}
                //      inline a_text& logfile() const {return &log_;}
                inline void printout(const std::string text) {output_ << text << std::endl;}
                inline void printout(const bool val) {output_ << val << std::endl;}
                static const std::string help();
                //layers management
                bool existlayer(const std::string& s) const;
                bool existlayer(const std::string& s, a_screenlayer *&) const;
                virtual void newlayer(const std::string& s);
                void newlayer(const a_screenlayer& l);
                virtual void setlayer(const std::string& s);
                virtual void eraselayer(const std::string& s);
                void setofflayer(const std::string& s);
                void setonlayer(const std::string& s);
                const std::string getlayer() const;
                std::string  listlayers();
                void color(float r, float g, float b);
                void R(double v) {active_layer_->R(v);}
                void G(double v) {active_layer_->G(v);}
                void B(double v) {active_layer_->B(v);}
                inline double R() const {return active_layer_->R();}
                inline double G() const {return active_layer_->G();}
                inline double B() const {return active_layer_->B();}
                void thickness(const int); 
                inline int thickness() const {return active_layer_->thickness();}
                void spotlight();
                void sunlight();
                void parallel_view();
                void perspectia_view();
 
                //bounds utilities
                inline bool empty() const {return empty_;}
                inline void empty(bool code) {empty_ = code;}
                //
                virtual void interact();
                void getinteract() {std::cout << *iren_ << std::endl;};
                void point(const a_point& p);
                void point(double x, double y, double z);
                void line(const a_point& p1, const a_point& p2);
                void line(double x1, double y1, double z1,
                                double x2, double y2, double z2);
                void vertex(const a_point& p);
                void vertex(double x, double y, double z);
                void endpolyline();
                void closepolyline();
                void vertex0(double x, double y, double z);
                void endpolyline0();
                void closepolyline0();
                void surfacepoint(const a_point& p);
                void surfacepoint(double x, double y, double z);
                void eraselastpoint();
                void eraselastline();
                void eraselastpolyline();
 
                //viewing member functions
                void viewpoint(const a_point& pt);
                void focalpoint(const a_point& pt);
                void viewpoint(const double * pt);
                void focalpoint(const double * pt);
                a_point viewpoint() const;
                a_point focalpoint() const;
                void pan(const double * pt);
                void azimuth(double x);
                void elevation(double y);
                void roll(double z);
                void pitch(double u);
                void yaw(double v);
                void distance(double d);
                void distance0(double d);
                double azimuth()   const {return x0_;}
                double elevation() const {return y0_;}
                double roll()      const {return z0_;}
                double distance()  const;
 
                void background(double R, double G, double B);
                inline void fullscreenon() {renWin_->SetSize(1280,1024);}
                inline void fullscreenoff() {renWin_->SetSize(640,480);}
                inline void cursor_show() {renWin_->ShowCursor();}
                inline void cursor_hide() {renWin_->HideCursor();}
 
                //import/export
                void output_position();
                void dxfin(const std::string& file);
                void dxfout(const std::string& file);
                void ptin(const std::string& file);
                void ptout(const std::string& file);
                void tifout(const std::string& file);
                void jpgout(const std::string& file);
                void pngout(const std::string& file);
                void vrmlout(const std::string& file);   
                void vtkout(const std::string& file);
                void ribout(const std::string& file);
 
                inline void render() {renWin_->Render();}
                void render_clip();
                void reset();
 
                //: input/output
                friend   std::istream&    operator>> (std::istream& i, a_screen& w);
                friend   std::ostream&   operator<< (std::ostream& o, a_screen& w);
                void open(const std::string& file);
                void save(const std::string& file);
 
                class filenotfound_error {};
                class file_error {};
                class notallowed_error {};
                class model_uni_not_found_error {};
                class no_layer_error {};
 
        protected:
                vtkPolyData * data_;
                std::vector<a_screenlayer *> layers_;         
                a_screenlayer * active_layer_;
                vtkRenderer * ren_;
                vtkRenderWindow * renWin_;
                vtkRenderWindowInteractor * iren_;
                //orientation references
                double x0_;  
                double y0_;
                double z0_;
                float clip_[2];
                bool spotlight_;
                a_text  output_; 
                a_text  log_;   
                /*if there's already one graphic element*/
                bool empty_; 
                bool one_point_; 
 
                void point0(double x, double y, double z);
                void line0(double x1, double y1, double z1,
                                double x2, double y2, double z2);
                void setlightoncameraposition();
                void unroll();
 
};
 
#endif