Cylinder.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef CYLINDER_H
#define CYLINDER_H

#include <esg/geometry/Geometry.h>

namespace esg {

class Cylinder : public Geometry {
protected:
        double  _radius;     
        double  _radiusSqr;  
        Vector3 _cap1Point;  
        Vector3 _cap1Normal; 
        Vector3 _cap2Point;  
        Vector3 _cap2Normal; 
        Vector3 _axis;       
        
protected:
        virtual Mesh* _mesh (int /*density*/) const { return NULL; } // TO DO !
        virtual void  _duplicate_attributes (const Geometry& /* src */);
    
        // Geometric transformations
        virtual void  _rotateX   (float /* angle */);
        virtual void  _rotateY   (float /* angle */);
        virtual void  _rotateZ   (float /* angle */);
        virtual void  _rotate    (float /* angle */,const Vector3& /* axis */);
        virtual void  _rotate    (const Matrix3&);
        virtual void  _translate (float /* x */, float /* y */, float /* z */);
        virtual void  _transform (const Matrix4&);
        virtual void  _scale     (float);

    
public:
        Cylinder();

        Cylinder(const Vector3& point1,
                 const Vector3& normal1,
                 const Vector3& point2,
                 const Vector3& normal2,
                 double         radius);

        virtual ~Cylinder() {}

        virtual void rayIntersection (PointEnv*      pPE,
                                      int            mask,
                                      const Vector3& origin,
                                      const Vector3& direction,
                                      float          maxD = MAXFLOAT);

        virtual bool mapToUV (const Vector3& v, Vector2& uv); // to do 
        
        virtual void randomSample (int mask, PointEnv& pe, double* pdf); // to do

        virtual bool randomDirection (const Vector3& pov,
                                      Vector3&       dir,
                                      double*        pdf)
              {
                  return false; // TO DO!
              }

        virtual Interval extent (const Vector3& direction) const;

        virtual Vector3 centroid (void) const;

        virtual double radius (const Vector3& centroid) const; 
        
        virtual double radius (void) const;

        virtual Geometry* clone (const Matrix4* pTrMat) const;

        virtual bool separation (Geometry& geom, Vector3*  pDir);

        virtual double distance (const Geometry& geom, Vector3* pDir);

        virtual void dump (const char* intent, const char* tab);

    
        double getRadius() const { return _radius; }
        
        void setRadius(double radius) {
            _radius = radius;
            _radiusSqr = radius * radius;
        }

        void setFirstCap(const Vector3& center, const Vector3& normal) {
            _cap1Point.set(center);
            _cap1Normal.set(normal);
            _axis.set(_cap2Point);
            _axis.sub(_cap1Point);
            _axis.normalize();
        }

        void setSecondCap(const Vector3& center, const Vector3& normal) {
            _cap2Point.set(center);
            _cap2Normal.set(normal);
            _axis.set(_cap2Point);
            _axis.sub(_cap1Point);
            _axis.normalize();
        }
};
    
}; // namespace

#endif // CYLINDER_H

---