src/DepthOfFieldCamera.h

Go to the documentation of this file.

#ifndef DEPTHOFFIELDCAMERA_H
#define DEPTHOFFIELDCAMERA_H


#include <cmath>

#include "Camera.h"

#include "InfinitePlane.h"

class DepthOfFieldCamera : public Camera
{
public:
    DepthOfFieldCamera( Vec3f   pos,
                        Vec3f   dir,
                        Vec3f   up,
                        float   angle,
                        int     resX,
                        int     resY )
        : Camera(pos, resX, resY),
            mDir(dir),
            mUp(up),
            mAngle(angle * M_PI / 180.0f),
            mFocus(0.0f),
            mAspect(),
            mXAxis(),
            mYAxis(),
            mFocusDistance(0.3f),  //some good values i tested
            mAperture(0.0030f),
            mSlowCorrect(true),
            mActSample(0)
    {
        mDir.normalize();
        mUp.normalize();

        mXAxis = mDir.cross(mUp).normal();
        mYAxis = mXAxis.cross(mDir).normal();

        mAspect = static_cast<float>(resX) / resY;
        mFocus = 1.f / tanf(mAngle / 2.0f);
    }

    virtual ~DepthOfFieldCamera()
    {}

    virtual Ray initRay(float x, float y)
    {
        Vec3f rdir  = (2.0f * ((x / mResX - .5f) * mAspect) * mXAxis)
                        + (2.0f * (y / mResY - .5f) * mYAxis)
                        + (mFocus * mDir);
 
        rdir.normalize();

        Vec3f P;
        if(! mSlowCorrect)
        {
            P = mPos + rdir * mFocusDistance;
        }
        else
        {
            InfinitePlane plane(mPos+mFocusDistance*mDir, -mDir);
            Ray ray;
            ray.init(mPos, rdir);
            if(plane.intersect(ray))
            {
                P = ray.hitPoint(0);
            }
            else
                assert(false);
        }


        const float radius = mAperture * frand();
        const float alpha = 2*M_PI*(frand() + mActSample )/ mDepthSamples;
        float u = radius * cosf( alpha );
        float v = radius * sinf( alpha );

        mActSample = (mActSample +1) % mDepthSamples;
        //u = 0;
        //       v = 0;

        Vec3f pos = mPos + u*mXAxis + v*mYAxis;

        const Vec3f dir = P - pos;
        //const Vec3f dir = rdir;
        Ray ray;
        ray.init(pos, dir);
        //mRay.init(mPos,rdir);
        return ray;
    }

    void setPos(Vec3f pos)
    {
        mPos = pos;
    }

    void setDir(Vec3f dir)
    {
        mDir = dir;

        mDir.normalize();
        mUp.normalize();

        mXAxis = mDir.cross(mUp).normal();
        mYAxis = mXAxis.cross(mDir).normal();

        mAspect = static_cast<float>(mResX) / mResY;
        mFocus = 1.f / tanf(mAngle / 2.0f);
    }

    void setUp(Vec3f up)
    {
        mUp = up;

        mDir.normalize();
        mUp.normalize();

        mXAxis = mDir.cross(mUp).normal();
        mYAxis = mXAxis.cross(mDir).normal();

        mAspect = static_cast<float>(mResX) / mResY;
        mFocus = 1.f / tanf(mAngle / 2.0f);
    }

    virtual const Vec3f & dir() const
    {
        return mDir;
    }

    const Vec3f & up() const
    {
        return mUp;
    }

    float angle() const
    {
        return mAngle / M_PI * 180.0f;
    }

    float aspect() const
    {
        return mAspect;
    }

    virtual const float focusDistance() const
    {
        return mFocusDistance;
    }

    virtual const float aperture() const
    {
        return mAperture;
    }
    int depthSamples() const
    {
        return mDepthSamples;
    }

    void setDepthSamples(unsigned int i)
    {
        LOG("samples set to: " << i);
        mDepthSamples = i;
    }

    void setFocusDistance(float f)
    {
        LOG("distance set to: " << f);
        assert(f>0);
        mFocusDistance = f;
    }

    void setAperture(float a)
    {
        LOG("aperture set to: " << a);
        assert(a>0);
        mAperture = a;
    }

    void setSlowCorrect()
    {
        mSlowCorrect = true;
    }

    void setFastIncorrect()
    {
        mSlowCorrect = false;
    }

private:
    Vec3f   mDir;

    Vec3f   mUp;

    float   mAngle;

    float   mFocus;

    float   mAspect;

    Vec3f   mXAxis;

    Vec3f   mYAxis;

    float mFocusDistance;

    float mAperture;

    unsigned int mDepthSamples;

    bool mSlowCorrect;

    int mActSample;
};

#endif

---