raytrace.h

Go to the documentation of this file.

#pragma once
#include "lightsrc_mc.h"
#include "lightsrc.h"
#include "objectshape.h"
#include "vector.h"
#include "detector.h"
#include "raybase.h"
#include "superarray.h"
#include <vector>
 
namespace GOAT
{
    namespace raytracing
    {
        #define RAYTRACER_TYPE_NONE 0
        #define RAYTRACER_TYPE_PATH 1
        #define RAYTRACER_TYPE_OT   2   
        #define RAYTRACER_TYPE_PURE  3
 
        #define MAX_RECURSIONS 20
        #define RAYTRACE_MAX_REFLEXIONS 2
        class Scene
        {
        public:
            Scene();  
            Scene(const Scene& S); 
            void setPhaseProgress(bool suppress_phase_progress);
            void addObject(ObjectShape* Obj); 
            void addObjectList(int nobj, std::vector<ObjectShape*> obj); 
            void removeObject(int index); 
            void removeObject(ObjectShape* obj); 
            void removeAllObjects(); 
            void addLightSource(LightSrc* ls) { addLightSource(ls, raytype); } 
            void addLightSource(LightSrc* ls, int raytype); 
            void removeLightSrc(int index); 
            void removeLightSource(LightSrc* ls);
            void removeAllLightSources(); 
            void addLightSourceRRT(LightSrc* ls, maths::Vector<std::complex<double> >Pol1, maths::Vector<std::complex<double> >Pol2);
            void addLightSourceList(int nls, std::vector<LightSrc*> ls); 
            void addDetector(Detector* D); 
            void addDetectorList(int nDet, std::vector< Detector*> D); 
            void removeAllDetectors(); 
            void removeDetector(int index); 
            void removeDetector(Detector* det);
            void cleanAllDetectors(); 
            void setr0(double r0); 
            void setnS(std::complex<double> nS); 
            void setnSRRT(std::complex<double> nS); 
            void setRaytype(int raytype); 
            void setNumReflex(int numReflex); 
            void resetLS(); 
            int testLS(); 
            std::vector<ObjectShape*> Obj; 
            std::vector<LightSrc*> LS; 
            LightSrc* LSRRT; 
            std::vector< Detector*> Det; 
            int nObj = 0; 
            int nLS = 0;  
            int nDet = 0; 
            int nReflex = 0; 
            std::complex<double> nS; 
            std::complex<double> nSRRT; 
            double r0=1000; 
            int raytype=LIGHTSRC_RAYTYPE_IRAY; 
            bool suppress_phase_progress = false; 
            INDEX_TYPE NumCellsPerDir = 1; 
            INDEX_TYPE getNumberOfCellsPerDirection() const { return NumCellsPerDir; }
            void setNumberOfCellsPerDirection(INDEX_TYPE no)  { NumCellsPerDir = no; }
        };
 

        class Raytrace
        {
        public:
            Raytrace();
            Raytrace(const Scene& S);
            void setScene(const Scene& S); 
            void setNumReflex(int numReflex); 
            void trace(); 
            virtual void traceEnterObject() = 0; 
            virtual void traceLeaveObject() = 0; 
            virtual void traceStopObject() {}; 
            void init(); 
            int lost; 
            int currentObj; 
            int currentLS; 
            GOAT::maths::Vector<INDEX_TYPE> currentIndex= GOAT::maths::Vector<INDEX_TYPE>(-1, -1, -1);
            maths::Vector<double> PStart, PStop; 
            maths::Vector<std::complex<double> > EStart, EStop; 
            maths::Vector<std::complex<double> > EStart2, EStop2;  

            maths::Vector<double> kin; 
            maths::Vector<double> kref; 
            maths::Vector<double> ktrans; 

            double PowRef; 
            double PowIn; 
            double PowTrans; 
            Scene S; 
            bool useRRTParms; 
            int type=RAYTRACER_TYPE_NONE; 
 
        
            virtual void traceOneRay(RayBase* ray, int& Reflexions, int& recur); 
            virtual void reset();
            void copyRay(RayBase*& dest, RayBase* src);
            RayBase* ray; 
            RayBase* tray; 
            bool Abbruch; 
            int numReflex = RAYTRACE_MAX_REFLEXIONS;    
        };

        class Raytrace_OT : public Raytrace
        {
        public:
            Raytrace_OT();
            Raytrace_OT(Scene S);
            void setScene(const Scene& S);
            void trace();
            void traceLeaveObject(); 
            void traceEnterObject(); 
            maths::Vector<double>* F; 
            maths::Vector<double>* L; 
            maths::Vector<double>** f; 
            maths::Vector<double>** l;
        };
 

        class Raytrace_Path : public Raytrace
        {
        public:
            Raytrace_Path();
            Raytrace_Path(Scene); 
            void trace(std::string FName); 
            void trace(); 
            void setShowOutgoingRays(bool show); 
            bool getShowOutgoingRays(); 
            std::vector<maths::Vector<double>> P1; 
            std::vector<maths::Vector<double>> P2; 
            int numRays=0; 
        private:
            void traceLeaveObject();
            void traceEnterObject();
            void storeStep();
            void traceStopObject();
            std::ofstream os;
            bool showOutgoingRays = true;
            bool storeInFile = false;
 
        };

        class Raytrace_pure : public Raytrace
        {
        public:
            Raytrace_pure();
            Raytrace_pure(const Scene&); 
        private:
            void traceLeaveObject() {};
            void traceEnterObject() {};
        };
 
    }
}