objectshape.h

Go to the documentation of this file.

/***************************************************************************
                          objectshape.h  -  description
                             -------------------
    begin                : Wed Oct 24 2001
    copyright            : (C) 2001 by Thomas Weigel
    email                : weigel@lat.ruhr-uni-bochum.de
 ***************************************************************************/
 

#pragma once
 
#ifndef INF
#define INF 1.0/0.0
#endif
#include "matrix.h"
#include "vector.h"
 
#include <fstream>
// #include <time.h>
namespace GOAT {
    namespace raytracing {
#define OBJECTSHAPE_NO_SHAPE    -1  //F/< No shape defined
#define OBJECTSHAPE_ELLIPSOID     10000  
#define OBJECTSHAPE_SURFACE       10001 
#define OBJECTSHAPE_CONE          10002 
#define OBJECTSHAPE_ASPHERIC_LENS 10003 
#define OBJECTSHAPE_SPHERIC_LENS  10004 
#define OBJECTSHAPE_BOX           10005 
#define OBJECTSHAPE_CYLINDER      10006 
#define OBJECTSHAPE_VORTEX_PLATE  10007 
 
 
#define FUNSURF          2  
#define SUPERELLIPSOID_D 17 
#define SUPERELLIPSOID   4
#define ZYLINDER     5
#define KREISKEGEL   6
#define KEGELSTUMPF  7
#define COMPOUND     8
#define SPIEGEL      12
#define SUPERELLIPSOID_N 10
#define ERYTHROCYTE      11
#define KEGELSTUMPF_HOHL 9 
#define HOHLFASER    13
#define NINCTYPES    14
#define LINSE        15
#define ZYLINDER_HEXAGONAL 16
#define BOX         3
#define EPS 1E-10*r0
 
        enum class NFUNCTYPE { vacuum, air, bk7, silica, lasf5, pmma };

        class ObjectShape {
        public:
            ObjectShape();
            ObjectShape(const ObjectShape& F);
 

            ObjectShape(const maths::Vector<double>& P,
                std::complex<double>  n,
                GOAT::maths::Matrix<std::complex<double> >  alpha,
                const maths::Vector<double>& Ex = maths::ex,
                const maths::Vector<double>& Ey = maths::ey,
                const maths::Vector<double>& Ez = maths::ez,
                const int type = -1
            );
 
 
            virtual void binWrite(std::ofstream& os) = 0;                    
            virtual void binRead(std::ifstream& os) = 0;                     
            void scale(double sf);                                
            virtual bool next(const maths::Vector<double>& p, const maths::Vector<double>& k,
                maths::Vector<double>& pout) = 0; 
 
            virtual maths::Vector<double> norm(const maths::Vector<double>& P) = 0;        
            virtual bool isInside(const maths::Vector<double>& p) = 0;              
            virtual double volume() = 0;                                      
 
            void setCenter(maths::Vector<double> P);                                
            void setCenter2CoM(); 
            bool isOutsideWorld(); 
            int Type() { return type; }                                         
            virtual void initQuad() = 0;                                      
            virtual  void setr0(double r0) = 0;                                 
            void setMatrix(maths::Matrix<double> H);                                
            void setMatrix(double alpha, double beta, double gamma);         
            void rotate(maths::Vector<double> A, double phi); 
 
            virtual void setPos(maths::Vector<double> r) = 0; 
            virtual void setPos(double x, double y, double z) = 0; 
            virtual maths::Vector<double> calcCoM() = 0;     
            void setn(std::complex<double> n) { this->n = n; }                       
            void setninel(std::complex<double> ninel) { this->ninel = ninel; }      
            std::complex<double> getninel() { return ninel; }                      
            std::complex<double> getn() { return n; }                              
            void setPolMatrix(maths::Matrix<std::complex<double> >alpha) { this->alpha = alpha; }   
            bool isActive() { return Active; }                                 
            void setActive(bool active) { Active = active; }                      
            void setAlpha(double Alpha) { setMatrix(Alpha, Ebeta, Egamma); }   
            void setBeta(double Beta) { setMatrix(Ealpha, Beta, Egamma); }     
            void setGamma(double Gamma) { setMatrix(Ealpha, Ebeta, Gamma); }   
            void setVisible(bool visible) { this->visible = visible; } 
            bool getVisible() { return visible; } 
            maths::Vector<double> P;                       
            maths::Matrix<double> H, R;                     
            std::complex<double>  n;                
            std::complex<double> ninel;             
            maths::Matrix<std::complex<double> > alpha;    
            int type;                               
            maths::Vector<double> pul, por;     
            maths::Vector<double> e[3];        
            double Ealpha, Ebeta, Egamma; 
            double r0;                  
            double sf=1;         
            bool Active;   
            double rho;        
            /*
            * @brief Used in the visualization part (GOATvis) => if true object will be visualized
            * If this parameter is true, GOATvis will show the full representation of the object in the scene dialog otherwise only the bounding box is shown.
            * This parameter can be used e.g. for very heavy surface object to safe memory.
            */
            bool visible=true;
            std::function <std::complex<double>(double)>  nfunc;
            NFUNCTYPE nfuncType=NFUNCTYPE::vacuum;
        };
 
        maths::Matrix<double> computeInertia(ObjectShape* F); 
        bool intersectionTest(ObjectShape& A, ObjectShape& B); 
    }
}