Camera.cc

Go to the documentation of this file.

#include <gra/camera/Camera.h>
#include <gra/camera/OrthoProj.h>
#include <assert.h>

using namespace gra;

Camera::Camera(AutoPtr<Projection> * pAP)
    : _pTrMat(NULL), _pAProjection(pAP)
{
    assert(_pAProjection);
    _pAProjection->registerReferer(this);
    _pProjection = _pAProjection->origObject();
    assert(_pProjection);
}

Camera::Camera()
    : _pTrMat(NULL), _pAProjection(NULL)
{
    _pAProjection = new AutoPtr<Projection>(new OrthoProj(-1.0, 1.0,
                                                          -1.0, 1.0,
                                                          -1.0, 1.0));
    _pAProjection->registerReferer(this);
    _pProjection = _pAProjection->origObject();
    assert(_pProjection);
}

Camera::Camera(const Camera& src)
    : _pTrMat(NULL)
{
    assert(src._pProjection);
    _pProjection = src._pProjection->clone();
    _pAProjection = new AutoPtr<Projection>(_pProjection);
    _pAProjection->registerReferer(this);

    if (src._pTrMat) _pTrMat = new Matrix4(*(src._pTrMat));
}

Camera::~Camera()
{
    if (_pTrMat) delete _pTrMat;
    (void) AutoPtr<Projection>::destroy(_pAProjection, this);
}

void Camera::setTransform(const Matrix4& trMat)
{
    if (_pTrMat) _pTrMat->set(trMat);
    else _pTrMat = new Matrix4(trMat);
}

void Camera::unsetTransform()
{
    if (_pTrMat) { delete _pTrMat; _pTrMat = NULL; }
}

void Camera::rotateX(float a)
{
    Matrix4 trMat;
    trMat.rotX(a);
    if (_pTrMat) _pTrMat->mul(trMat, *_pTrMat);
    else _pTrMat = new Matrix4(trMat);
}

void Camera::rotateY(float a)
{
    Matrix4 trMat;
    trMat.rotY(a);
    if (_pTrMat) _pTrMat->mul(trMat, *_pTrMat);
    else _pTrMat = new Matrix4(trMat);
}

void Camera::rotateZ(float a)
{
    Matrix4 trMat;
    trMat.rotZ(a);
    if (_pTrMat) _pTrMat->mul(trMat, *_pTrMat);
    else _pTrMat = new Matrix4(trMat);
}

void Camera::rotate(float a, const Vector3& axis)
{
    Matrix4 trMat;
    trMat.rotationGL(a, axis);
    if (_pTrMat) _pTrMat->mul(trMat, *_pTrMat);
    else _pTrMat = new Matrix4(trMat);
}

void Camera::translate(float x, float y, float z)
{
    Matrix4 trMat;
    trMat.setScaleTranslate(1, x, y, z);
    if (_pTrMat) _pTrMat->mul(trMat, *_pTrMat);
    else _pTrMat = new Matrix4(trMat);
}

bool Camera::isTransformed(Matrix4* pTrMat) const
{
    if (_pTrMat) {
        if (pTrMat) pTrMat->set(*_pTrMat);
        return true;
    } else 
        return false;
}

void Camera::setProjection(AutoPtr<Projection> * pProj)
{
    assert(pProj);
    AutoPtr<Projection>::destroy(_pAProjection, this);
    _pAProjection = pProj;
    _pAProjection->registerReferer(this);
    _pProjection = _pAProjection->origObject();
    assert(_pProjection);
}

Vector2 Camera::getPixelSize(unsigned resX, unsigned resY) const
{
    return Vector2((_pProjection->getRightPlane() - _pProjection->getLeftPlane()) / resX,
                   (_pProjection->getTopPlane() - _pProjection->getBottomPlane()) / resY);
}

void Camera::getProjectionPlane(Vector3& ll,
                                Vector3& ul,
                                Vector3& ur,
                                Vector3& lr) const
{
    _pProjection->getProjectionArea(ll, ul, ur, lr);
    if (_pTrMat) {
        _pTrMat->transform(ll);
        _pTrMat->transform(ul);
        _pTrMat->transform(ur);
        _pTrMat->transform(lr);
    }
}

Vector2 Camera::mapPixelToProjPlane(unsigned    posX,
                                    unsigned    posY,
                                    unsigned    resX,
                                    unsigned    resY,
                                    PixelSample sample) const
{
    double xSize =
        (_pProjection->getRightPlane() - _pProjection->getLeftPlane()) / resX;
    double ySize =
        (_pProjection->getTopPlane() - _pProjection->getBottomPlane()) / resY;

    Vector2 ret(xSize * posX, ySize * posY);

    switch (sample) {
    case PS_CENTROID:
        ret.x += .5 * xSize;
        ret.y += .5 * ySize;
        break;
    case PS_UPPER_LEFT_CORNER:
        ret.y += ySize;
        break;
    case PS_UPPER_RIGHT_CORNER:
        ret.x += xSize;
        ret.y += ySize;
        break;
    case PS_LOWER_RIGHT_CORNER:
        ret.x += xSize;
        break;
    case PS_LOWER_LEFT_CORNER:
        break;
    case PS_RANDOM:
        ret.x += ESG_DBL_RAND * xSize;
        ret.x += ESG_DBL_RAND * ySize;
        break;
    default:
        break;
    }

    return ret;
}

Vector3 Camera::getProjectionDirection(const Vector2& point)
{
    Vector3 dir = _pProjection->getProjectionDirection(point);
    if (_pTrMat) {
        Matrix3 rMat;
        _pTrMat->get(rMat);
        rMat.transform(dir);
    }
    return dir;
}

Vector3 Camera::getDirection()
{
    Vector3 dir(0.0, 0.0, -1.0);
    if (_pTrMat) {
        Matrix3 rMat;
        _pTrMat->get(rMat);
        rMat.transform(dir);
    }
    return dir;
}

Vector3 Camera::getZenith()
{
    Vector3 zenith(0.0, 1.0, 0.0);
    if (_pTrMat) {
        Matrix3 rMat;
        _pTrMat->get(rMat);
        rMat.transform(zenith);
    }
    return zenith;
}

Vector2 Camera::project(const Vector3& point) const
{
    if (_pTrMat) { // transform @point to local coord. system
        Matrix3 rMat;
        Vector3 tVec, sVec, p;
        _pTrMat->get(rMat, tVec, sVec);
        ESG_INVERSE_TR_POINT(rMat, tVec, sVec, point, p);
        Vector3 v(_pProjection->project(p)); // apply projection matrix
        return Vector2(v.x - _pProjection->getLeftPlane(),
                       v.y - _pProjection->getBottomPlane()); // project to plane end return
    } else {
        Vector3 v(_pProjection->project(point)); // apply projection matrix
        return Vector2(v.x - _pProjection->getLeftPlane(),
                       v.y - _pProjection->getBottomPlane()); // project to plane end return
    }
}

bool Camera::projectAndClip(const Vector3& point, Vector2* res) const
{
    Vector3 v;
    
    if (_pTrMat) { // transform @point to local coord. system
        Matrix3 rMat;
        Vector3 tVec, sVec, p;
        _pTrMat->get(rMat, tVec, sVec);
        ESG_INVERSE_TR_POINT(rMat, tVec, sVec, point, p);
        bool in = _pProjection->projectAndClip(p, &v);
        if (in && res) 
            res->set(v.x - _pProjection->getLeftPlane(),
                     v.y - _pProjection->getBottomPlane());
        return in;
    } else {
        bool in = _pProjection->projectAndClip(point, &v);
        if (in && res) 
            res->set(v.x - _pProjection->getLeftPlane(),
                     v.y - _pProjection->getBottomPlane());
        return in;
    }
}

---