a_canvas.h

Go to the documentation of this file.

/*
         Copyright 2010-2016 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_CANVAS_H_
#define _A_CANVAS_H_
 
// .NAME a_canvas 
// .PORTABILITY : ansi C++
// .SECTION Author
// Pierre Smars
 
class a_element;
 
#include "vtkPolyData.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
 
#include "a_element.h"
#include "a_text.h"
#include "a_point.h"
 
#include <string>
#include <vector>
 
class a_canvas
{
        public:
                a_canvas();
                ~a_canvas();
                void clear();
                virtual std::string type() const {return "a_canvas";}
                static const std::string help();
                void name(const std::string& name);
                inline std::string name() const {return name_;}
 
                void logfile(a_text& text);
                void outputfile(a_text& text);
                inline a_text& logfile() {return log_;}
                inline void printout(const std::string text) {output_ << text << std::endl;}
                inline void printout(const bool x) {output_ << x << std::endl;}
 
                //layers management
                bool existelement(const std::string& s) const;
                bool existelement(const std::string& s, a_element *&) const;
                void addelement(a_element& l);
                void setelement(const std::string& s);
                void unlinkelement(const std::string& s);
                void fitelements(const std::string& m, const std::string& p);
                const std::string getelementname() const;
                std::string  listelements();
                void spotlight();
                void sunlight();
                void parallel_view();
                void perspectia_view();
                double scale() const;
                void scale(double val);
                void magnification(unsigned short val); 
                //bounds utilities
                inline bool empty() const {return empty_;}
                inline void empty(bool code) {empty_ = code;}
                //
                virtual void interact();
                virtual void straighten();
                virtual void fit_interact();
                virtual void fit_deform_interact();
                virtual void cut_interact();
                void getinteract() {std::cout << *iren_ << std::endl;};
 
                //viewing member functions
                void viewpoint(const a_point& pt);
                void focalpoint(const a_point& pt);
                void up(const a_point& pt);
                void viewpoint(const double * pt);
                void focalpoint(const double * pt);
                void up(const double * pt);
                a_point viewpoint() const;
                a_point focalpoint() const;
                a_point up() 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;
                double elevation() const;
                double roll()      const;
                double distance()  const;
                void x();
                void X();
                void y();
                void Y();
                void z();
                void Z();
 
                void background(double R, double G, double B);
                inline void size(const int w, const int h) {renWin_->SetSize(w,h);}
                int width() const;
                int height() const;
                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 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);
                void tifout(const std::string& file);
 
                inline void render() {renWin_->Render();}
                void render_clip();
                void reset();
 
                //: input/output
                friend   std::istream&    operator>> (std::istream& i, a_canvas& w);
                friend   std::ostream&   operator<< (std::ostream& o, a_canvas& 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_element_error {};
 
        protected:
                virtual void reset_interact();
 
                std::string                     name_;
                std::vector<a_element *>        elements_;            
                a_element *                     active_element_;
                vtkRenderer *                   ren_;
                vtkRenderWindow *               renWin_;
                vtkRenderWindowInteractor *     iren_;
                float clip_[2];
                bool spotlight_;
                a_text  output_; 
                a_text  log_;   
                /*if there's already one graphic element*/
                bool empty_; 
                bool one_point_; 
                double magnification_;
                void setlightoncameraposition();
                void unroll();
};
 
#endif