Point3D.cc

Go to the documentation of this file.

#include <esg/geometry/Point3D.h>

using namespace esg;

void Point3D::_duplicate_attributes(const Geometry& a)
{
  _position.set(((Point3D&)a)._position);
}

void Point3D::_rotateX(float a)
{
    Matrix3 trMat;
    trMat.rotX(a);
    trMat.transform(_position);
}

void Point3D::_rotateY(float a)
{
    Matrix3 trMat;
    trMat.rotY(a);
    trMat.transform(_position);
}

void Point3D::_rotateZ(float a)
{
    Matrix3 trMat;
    trMat.rotZ(a);
    trMat.transform(_position);
}

void Point3D::_rotate(float a, const Vector3& axis)
{
    Matrix4 trMat;
    trMat.rotationGL(a, axis);
    trMat.transform(_position);
}

void Point3D::_rotate(const Matrix3& rotMat)
{
    rotMat.transform(_position);
}

void Point3D::_translate(float x, float y, float z)
{
    _position.add(Vector3(x, y, z));
}

void Point3D::_transform(const Matrix4& trMat)
{
    trMat.transform(_position);
}

void Point3D::_scale(float s)
{
    _position.scale(s);
}


//------- public -----------

Point3D::Point3D()
{
    _position.set(0,0,0);
}

Point3D::Point3D(const Vector3& v)
{
  _position.set(v);
}

Point3D::Point3D(float x, float y, float z)
{
  _position.set(x,y,z);
}

Point3D::Point3D(double x, double y, double z)
{
  _position.set(x,y,z);
}

void Point3D::rayIntersection(PointEnv*      pPE,
                              int            mask,
                              const Vector3& origin,
                              const Vector3& direction,
                              float          maxDist)
{
    pPE->mask = ENV_HAVE_NOTHING;

    Vector3 dist(_position - origin);
    float   cosinus = dist.dot(direction);

    if (maxDist < MAXFLOAT && dist.length() > maxDist) return;

    if (cosinus > (1 - EPS) && cosinus < (1 + EPS)) {
        pPE->mask |= ENV_HAVE_INTERFERENCE;
        if (mask & ENV_WANT_INTERSECTION) {
            pPE->intersection.set(_position);
            pPE->mask |= ENV_HAVE_INTERSECTION;
        }
        if (mask & ENV_WANT_DISTANCE) {
            pPE->distance = dist.length();
            pPE->mask |= ENV_HAVE_DISTANCE;
        }
        if (mask & ENV_WANT_UV_COORD) {
            pPE->uvCoord.set(0,0);
            pPE->mask |= ENV_HAVE_UV_COORD;
        }
    }
}

bool Point3D::mapToUV(const Vector3& v, Vector2& uv)
{
    return false;
}

void Point3D::randomSample(int mask, PointEnv& pe, double* pdf)
{
    pe.mask = ENV_HAVE_NOTHING;
    
    if (mask & ENV_WANT_SURFACE_POINT) {
        pe.intersection.set(_position);
        pe.mask |= ENV_HAVE_SURFACE_POINT;
    }
    if (mask & ENV_WANT_UV_COORD) {
        pe.uvCoord.set(0,0);
        pe.mask |= ENV_HAVE_UV_COORD;
    }

    if (pdf)
        cerr << "Sphere::randomDirection(): PDF is not implemented" << endl;
}

bool Point3D::randomDirection(const Vector3& pov, Vector3& dir, double* pdf) 
{
    dir.set(_position);
    dir.sub(pov);
    dir.normalize();

    if (pdf)
        cerr << "Sphere::randomDirection(): PDF is not implemented" << endl;
    
    return true;
}

Interval Point3D::extent(const Vector3& direction) const
{
  Interval retInt;
  retInt.min = direction.dot(_position);
  retInt.max = retInt.min;
  return retInt;
}

Geometry* Point3D::clone(const Matrix4* pTrMat) const
{
  Point3D* pRet = new Point3D();
  pRet->_duplicate_attributes(*this);
  if (pTrMat) pRet->_transform(*pTrMat);
  return pRet;
}

Vertex3 Point3D::centroid() const
{
    return _position;
}

double Point3D::radius() const
{
    return 0.0;
}

double Point3D::radius(const Vector3& centroid) const
{
    return ((Vector3)(centroid-_position)).length();
}

bool Point3D::separation(Geometry& geom, Vector3* pDir)
{
    Vector3d  v(geom.centroid() - _position);
    v.normalize();
    Interval i = geom.extent(v);
    float    d = _position.dot(v);
    if (d < i.min || d > i.max) {
        if (pDir) pDir->set(v);
        return true;
    } else
        return false;
}

double Point3D::distance(const Geometry& geom, Vector3* pDir)
{
    Vector3d  v(geom.centroid() - _position);
    v.normalize();
    Interval i  = geom.extent(v);
    float    d  = _position.dot(v);
    float    d1 = fabs(d-i.min);
    float    d2 = fabs(d-i.max);
    if (d1 < d2) {
        if (pDir) pDir->set(v);
        return d1;
    } else
        return d2;
}

void Point3D::dump(const char* intent, const char* tab)
{
    printf("%s geometry Point {", intent);
    printf("%s %s position %f %f %f\n", intent, tab, _position.x, _position.y, _position.z);
    printf("%s }", intent);
}

---