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