RayTracer.h

/* Copyright 2017 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 
#ifndef COM_DAFER45_TBTK_RAY_TRACER
#define COM_DAFER45_TBTK_RAY_TRACER
 
#include "TBTK/FieldWrapper.h"
#include "TBTK/Model.h"
#include "TBTK/Property/Density.h"
#include "TBTK/Property/LDOS.h"
#include "TBTK/Property/Magnetization.h"
#include "TBTK/Property/WaveFunctions.h"
#include "TBTK/TBTKMacros.h"
#include "TBTK/Vector3d.h"
 
#include <functional>
#include <initializer_list>
 
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
 
namespace TBTK{
 
class RayTracer{
public:
    RayTracer();
 
    RayTracer(const RayTracer &rayTracer);
 
    RayTracer(RayTracer &&rayTracer);
 
    ~RayTracer();
 
    RayTracer& operator=(const RayTracer &rhs);
 
    RayTracer& operator=(RayTracer &&rhs);
 
    void setCameraPosition(const Vector3d &cameraPosition);
 
    void setCameraPosition(std::initializer_list<double> cameraPosition);
 
    void setFocus(const Vector3d &focus);
 
    void setFocus(std::initializer_list<double> focus);
 
    void setUp(const Vector3d &up);
 
    void setUp(std::initializer_list<double> up);
 
    void setWidth(unsigned int width);
 
    void setHeight(unsigned int height);
 
    void setStateRadius(double stateRadius);
 
    void setNumDeflections(unsigned int numDeflections);
 
    unsigned int getNumDeflections() const;
 
    void setRayLength(double rayLength);
 
    double getRayLength() const;
 
    void setNumRaySegments(unsigned int numRaySegments);
 
    unsigned int getNumRaySegments() const;
 
    void plot(const Model& model, const Property::Density &density);
 
    void plot(
        const Model &model,
        const Property::Magnetization &magnetization
    );
 
    void plot(
        const Model &model,
        const Property::WaveFunctions &waveFunctions,
        unsigned int state
    );
 
    void plot(
        Field<std::complex<double>, double> &field
    );
 
    void plot(
        const std::vector<const FieldWrapper*> &fields
    );
 
    void interactivePlot(
        const Model &model,
        const Property::LDOS &ldos,
        double sigma = 0,
        unsigned int windowSize = 51
    );
 
    void save(std::string filename);
private:
    class Color{
    public:
        double r, g, b;
    };
 
    class Material{
    public:
        Material();
 
        Color color;
 
        double ambient, diffusive, emissive, specular;
 
        static constexpr double DEFAULT_AMBIENT = 1;
        static constexpr double DEFAULT_DIFFUSIVE = 0.5;
        static constexpr double DEFAULT_EMISSIVE = 0;
        static constexpr double DEFAULT_SPECULAR = 0.1;
    };
 
    class RenderContext{
    public:
        RenderContext();
 
        ~RenderContext();
 
        void setCameraPosition(const Vector3d &cameraPosition);
 
        void setCameraPosition(std::initializer_list<double> cameraPosition);
 
        const Vector3d& getCameraPosition() const;
 
        void setFocus(const Vector3d &focus);
 
        void setFocus(std::initializer_list<double> focus);
 
        const Vector3d& getFocus() const;
 
        void setUp(const Vector3d &up);
 
        void setUp(std::initializer_list<double> up);
 
        const Vector3d& getUp() const;
 
        void setWidth(unsigned int width);
 
        unsigned int getWidth() const;
 
        void setHeight(unsigned int height);
 
        unsigned int getHeight() const;
 
        void setStateRadius(double stateRadius);
 
        double getStateRadius() const;
 
        void setNumDeflections(unsigned int numDeflections);
 
        /*** Get number of deflections. */
        unsigned int getNumDeflections() const;
 
        void setRayLength(double rayLength);
 
        double getRayLength() const;
 
        void setNumRaySegments(unsigned int numRaySegments);
 
        unsigned int getNumRaySegments() const;
    private:
        Vector3d cameraPosition;
 
        Vector3d focus;
 
        Vector3d up;
 
        double width;
 
        double height;
 
        double stateRadius;
 
        unsigned int numDeflections;
 
        double rayLength;
 
        unsigned int numRaySegments;
    };
 
    RenderContext renderContext;
 
    class HitDescriptor{
    public:
        HitDescriptor(const RenderContext &renderContext);
 
        HitDescriptor(const HitDescriptor &hitDescriptor);
 
        HitDescriptor(HitDescriptor &&hitDescriptor);
 
        ~HitDescriptor();
 
        HitDescriptor& operator=(const HitDescriptor &rhs);
 
        HitDescriptor& operator=(HitDescriptor &&rhs);
 
        void setRaySource(const Vector3d &raySource);
 
        const Vector3d& getRaySource() const;
 
        void setRayDirection(const Vector3d &rayDirection);
 
        const Vector3d& getRayDirection() const;
 
        void setIndex(const Index &index);
 
        const Index& getIndex() const;
 
        void setCoordinate(const Vector3d coordainte);
 
        const Vector3d& getCoordinate() const;
 
        const Vector3d& getDirectionFromObject();
 
        const Vector3d& getImpactPosition();
    private:
        const RenderContext *renderContext;
 
        Vector3d raySource;
 
        Vector3d rayDirection;
 
        Index index;
 
        Vector3d coordinate;
 
        Vector3d *directionFromObject;
 
        Vector3d *impactPosition;
    };
 
    class RenderResult{
    public:
        RenderResult(unsigned int width, unsigned int height);
 
        RenderResult(const RenderResult &renderResult);
 
        RenderResult(RenderResult &&renderResult);
 
        ~RenderResult();
 
        RenderResult& operator=(const RenderResult &rhs);
 
        RenderResult& operator=(RenderResult &&rhs);
 
        cv::Mat& getCanvas();
 
        const cv::Mat& getCanvas() const;
 
        std::vector<HitDescriptor>** getHitDescriptors();
    private:
        unsigned int width, height;
 
        cv::Mat canvas;
 
        std::vector<HitDescriptor> **hitDescriptors;
    };
 
    RenderResult *renderResult;
 
    void render(
        const IndexDescriptor &indexDescriptor,
        const Model &model,
        const std::vector<const FieldWrapper*> &fields,
        std::function<Material(HitDescriptor &hitDescriptor)> &&lambdaColorPicker,
        std::function<void(cv::Mat &canvas, const Index &index)> &&lambdaInteractive = {}
    );
 
    Color trace(
        const std::vector<Vector3d> &coordinates,
        const Vector3d &raySource,
        const Vector3d &rayDirection,
        const IndexTree &indexTree,
        const std::vector<const FieldWrapper*> &fields,
        std::vector<HitDescriptor> &hitDescriptors,
        std::function<Material(HitDescriptor &hitDescriptor)> lambdaColorPicker,
        unsigned int deflections = 0
    );
 
    Color traceFields(
        const std::vector<const FieldWrapper*> &fields,
        const Vector3d &raySource,
        const Vector3d &rayDirection
    );
 
    cv::Mat getCharImage() const;
 
    class EventHandler{
    public:
        static bool lock(
            RayTracer *owner,
            std::function<void(
                int event,
                int x,
                int y,
                int flags,
                void *userData
            )> &&lambdaOnMouseChange
        );
 
        static bool unlock(const RayTracer *owner);
 
        static void onMouseChange(
            int event,
            int x,
            int y,
            int flags,
            void *userdata
        );
    private:
        static bool isLocked;
 
        static RayTracer *owner;
 
        static std::function<void(int event, int x, int y, int flags, void *userData)> &&lambdaOnMouseChange;
    };
};
 
inline void RayTracer::setCameraPosition(const Vector3d &cameraPosition){
    renderContext.setCameraPosition(cameraPosition);
}
 
inline void RayTracer::setCameraPosition(
    std::initializer_list<double> cameraPosition
){
    renderContext.setCameraPosition(cameraPosition);
}
 
inline void RayTracer::setFocus(const Vector3d &focus){
    renderContext.setFocus(focus);
}
 
inline void RayTracer::setFocus(std::initializer_list<double> focus){
    renderContext.setFocus(focus);
}
 
inline void RayTracer::setUp(const Vector3d &up){
    renderContext.setUp(up);
}
 
inline void RayTracer::setWidth(unsigned int width){
    renderContext.setWidth(width);
}
 
inline void RayTracer::setHeight(unsigned int height){
    renderContext.setHeight(height);
}
 
inline void RayTracer::setUp(std::initializer_list<double> up){
    renderContext.setUp(up);
}
 
inline void RayTracer::setStateRadius(double stateRadius){
    renderContext.setStateRadius(stateRadius);
}
 
inline void RayTracer::setNumDeflections(unsigned int numDeflections){
    renderContext.setNumDeflections(numDeflections);
}
 
inline unsigned int RayTracer::getNumDeflections() const{
    return renderContext.getNumDeflections();
}
 
inline void RayTracer::setRayLength(double rayLength){
    renderContext.setRayLength(rayLength);
}
 
inline double RayTracer::getRayLength() const{
    return renderContext.getRayLength();
}
 
inline void RayTracer::setNumRaySegments(unsigned int numRaySegments){
    renderContext.setNumRaySegments(numRaySegments);
}
 
inline unsigned int RayTracer::getNumRaySegments() const{
    return renderContext.getNumRaySegments();
}
 
/*inline RayTracer::RenderResult::RenderResult(
    unsigned int width,
    unsigned int height
){
    this->width = width;
    this->height = height;
 
    canvas = cv::Mat(height, width, CV_32FC3);
 
    hitDescriptors = new std::vector<HitDescriptor>*[width];
    for(unsigned int x = 0; x < width; x++)
        hitDescriptors[x] = new std::vector<HitDescriptor>[height];
}
 
inline RayTracer::RenderResult::~RenderResult(){
    for(unsigned int x = 0; x < width; x++)
        delete [] hitDescriptors[x];
    delete [] hitDescriptors;
}*/
 
inline cv::Mat& RayTracer::RenderResult::getCanvas(){
    return canvas;
}
 
inline const cv::Mat& RayTracer::RenderResult::getCanvas() const{
    return canvas;
}
 
inline std::vector<RayTracer::HitDescriptor>** RayTracer::RenderResult::getHitDescriptors(){
    return hitDescriptors;
}
 
inline RayTracer::Material::Material(){
    color.r = 0;
    color.g = 0;
    color.b = 0;
    ambient = DEFAULT_AMBIENT;
    diffusive = DEFAULT_AMBIENT;
    emissive = DEFAULT_EMISSIVE;
    specular = DEFAULT_SPECULAR;
}
 
inline void RayTracer::RenderContext::setCameraPosition(
    const Vector3d &cameraPosition
){
    this->cameraPosition = cameraPosition;
}
 
inline void RayTracer::RenderContext::setCameraPosition(
    std::initializer_list<double> cameraPosition
){
    TBTKAssert(
        cameraPosition.size() == 3,
        "RayTracer::setCameraPosition()",
        "Camera position can only have three coordinates.",
        ""
    );
 
    this->cameraPosition.x = *(cameraPosition.begin() + 0);
    this->cameraPosition.y = *(cameraPosition.begin() + 1);
    this->cameraPosition.z = *(cameraPosition.begin() + 2);
}
 
inline const Vector3d& RayTracer::RenderContext::getCameraPosition() const{
    return cameraPosition;
}
 
inline void RayTracer::RenderContext::setFocus(const Vector3d &focus){
    this->focus = focus;
}
 
inline void RayTracer::RenderContext::setFocus(
    std::initializer_list<double> focus
){
    TBTKAssert(
        focus.size() == 3,
        "RayTracer::setFocus()",
        "Focus can only have three coordinates.",
        ""
    );
 
    this->focus.x = *(focus.begin() + 0);
    this->focus.y = *(focus.begin() + 1);
    this->focus.z = *(focus.begin() + 2);
}
 
inline const Vector3d& RayTracer::RenderContext::getFocus() const{
    return focus;
}
 
inline void RayTracer::RenderContext::setUp(const Vector3d &up){
    this->up = up;
}
 
inline void RayTracer::RenderContext::setUp(
    std::initializer_list<double> up
){
    TBTKAssert(
        up.size() == 3,
        "RayTracer::setCameraPosition()",
        "Camera position can only have three coordinates.",
        ""
    );
 
    this->up.x = *(up.begin() + 0);
    this->up.y = *(up.begin() + 1);
    this->up.z = *(up.begin() + 2);
}
 
inline const Vector3d& RayTracer::RenderContext::getUp() const{
    return up;
}
 
inline void RayTracer::RenderContext::setWidth(unsigned int width){
    this->width = width;
}
 
inline unsigned int RayTracer::RenderContext::getWidth() const{
    return width;
}
 
inline void RayTracer::RenderContext::setHeight(unsigned int height){
    this->height = height;
}
 
inline unsigned int RayTracer::RenderContext::getHeight() const{
    return height;
}
 
inline void RayTracer::RenderContext::setStateRadius(double stateRadius){
    this->stateRadius = stateRadius;
}
 
inline double RayTracer::RenderContext::getStateRadius() const{
    return stateRadius;
}
 
inline void RayTracer::RenderContext::setNumDeflections(
    unsigned int numDeflections
){
    this->numDeflections = numDeflections;
}
 
inline unsigned int RayTracer::RenderContext::getNumDeflections() const{
    return numDeflections;
}
 
inline void RayTracer::RenderContext::setRayLength(double rayLength){
    this->rayLength = rayLength;
}
 
inline double RayTracer::RenderContext::getRayLength() const{
    return rayLength;
}
 
inline void RayTracer::RenderContext::setNumRaySegments(
    unsigned int numRaySegments
){
    this->numRaySegments = numRaySegments;
}
 
inline unsigned int RayTracer::RenderContext::getNumRaySegments() const{
    return numRaySegments;
}
 
inline void RayTracer::HitDescriptor::setRaySource(
    const Vector3d &raySource
){
    this->raySource = raySource;
}
 
inline const Vector3d& RayTracer::HitDescriptor::getRaySource() const{
    return this->raySource;
}
 
inline void RayTracer::HitDescriptor::setRayDirection(
    const Vector3d &rayDirection
){
    this->rayDirection = rayDirection;
}
 
inline const Vector3d& RayTracer::HitDescriptor::getRayDirection() const{
    return this->rayDirection;
}
 
inline void RayTracer::HitDescriptor::setIndex(const Index &index){
    this->index = index;
}
 
inline const Index& RayTracer::HitDescriptor::getIndex() const{
    return index;
}
 
inline void RayTracer::HitDescriptor::setCoordinate(const Vector3d coordinate){
    this->coordinate = coordinate;
}
 
inline const Vector3d& RayTracer::HitDescriptor::getCoordinate() const{
    return coordinate;
}
 
inline bool RayTracer::EventHandler::lock(
    RayTracer *owner,
    std::function<void(
        int event,
        int x,
        int y,
        int flags,
        void *userData
    )> &&lambdaOnMouseChange
){
    if(isLocked){
        return false;
    }
    else{
        isLocked = true;
        EventHandler::owner = owner;
        EventHandler::lambdaOnMouseChange = lambdaOnMouseChange;
        return true;
    }
}
 
inline bool RayTracer::EventHandler::unlock(const RayTracer *owner){
    if(EventHandler::owner == owner){
        EventHandler::owner = nullptr;
        EventHandler::isLocked = false;
        EventHandler::lambdaOnMouseChange = nullptr;
        return true;
    }
    else{
        return false;
    }
}
 
inline void RayTracer::EventHandler::onMouseChange(
    int event,
    int x,
    int y,
    int flags,
    void *userData
){
    if(lambdaOnMouseChange){
        lambdaOnMouseChange(event, x, y, flags, userData);
    }
    else{
        TBTKExit(
            "RayTracer::EventHandler::onMouseChange()",
            "lambdaOnMouseChange is nullptr.",
            "This should never happen, contact the developer."
        );
    }
}
 
};  //End namespace TBTK
 
#endif