osg::Line Class Reference
[Base]

#include <OSGLine.h>

List of all members.

Public Member Functions
Constructors
	Line (void)
	Line (const Line &obj)
	Line (const Pnt3f &p0, const Pnt3f &p1)
	Line (const Pnt3f &pos, const Vec3f &dir)
Destructor
	~Line (void)
Set
void	setValue (const Pnt3f &p0, const Pnt3f &p1)
void	setValue (const Pnt3f &pos, const Vec3f &dir)
Class Specific
bool	getClosestPoints (const Line &line2, Pnt3f &ptOnThis, Pnt3f &ptOnLine2) const
Pnt3f	getClosestPoint (const Pnt3f &point) const
Real32	distance (const Pnt3f &point) const
Get
const Pnt3f &	getPosition (void) const
const Vec3f &	getDirection (void) const
Intersection
bool	intersect (const SphereVolume &sphere) const
bool	intersect (const SphereVolume &sphere, Real32 &enter, Real32 &exit) const
bool	intersect (const CylinderVolume &cyl) const
bool	intersect (const CylinderVolume &cyl, Real32 &enter, Real32 &exit) const
bool	intersect (const FrustumVolume &frustum) const
bool	intersect (const FrustumVolume &frustum, Real32 &enter, Real32 &exit) const
bool	intersect (const BoxVolume &box, Real32 &enter, Real32 &exit) const
bool	intersect (Real32 angle, const BoxVolume &box) const
bool	intersect (Real32 angle, const Vec3f &point) const
bool	intersect (Real32 angle, const Vec3f &v0, const Vec3f &v1, Vec3f &pt) const
bool	intersect (const Pnt3f &v0, const Pnt3f &v1, const Pnt3f &v2, Real32 &t, Vec3f *normal=NULL) const
Private Attributes
Pnt3f	_pos
Vec3f	_dir

---

Detailed Description

A line starting at a point p and extending infinitely far into the direction d. This will probably split up into multiple classes for dual-inifinite and non-infinite lines

Definition at line 56 of file OSGLine.h.

---

Constructor & Destructor Documentation

Line::Line

(

void

)

Definition at line 68 of file OSGLine.cpp.

               : 
    _pos(0.f, 0.f ,0.f), 
    _dir(0.f, 0.f, 0.f)
{
}

Line::Line

(

const Line &

obj

)

Definition at line 75 of file OSGLine.cpp.

                          : 
    _pos(obj._pos), 
    _dir(obj._dir)
{
}

Line::Line	(	const Pnt3f &	p0,
		const Pnt3f &	p1
	)

Definition at line 82 of file OSGLine.cpp.

References setValue().

{
    setValue(p0, p1);
}

Line::Line	(	const Pnt3f &	pos,
		const Vec3f &	dir
	)

Definition at line 88 of file OSGLine.cpp.

References setValue().

{
    setValue(pos, dir);
}

Line::~Line

(

void

)

Definition at line 96 of file OSGLine.cpp.

{
}

---

Member Function Documentation

void Line::setValue	(	const Pnt3f &	p0,
		const Pnt3f &	p1
	)

Definition at line 102 of file OSGLine.cpp.

References _dir, _pos, and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize().

Referenced by osg::Navigator::calcDeltas(), osg::Camera::calcViewRay(), osg::WalkNavigator::forward(), osg::Plane::intersect(), osg::Transform::intersectActorEnter(), Line(), and osg::WalkNavigator::right().

{
    _pos = p0;
    _dir = p1 - p0;

    _dir.normalize();
}

void Line::setValue	(	const Pnt3f &	pos,
		const Vec3f &	dir
	)

Definition at line 111 of file OSGLine.cpp.

References _dir, _pos, and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize().

{
    _pos = pos;
    _dir = dir;
    _dir.normalize();
}

bool Line::getClosestPoints	(	const Line &	line2,
		Pnt3f &	ptOnThis,
		Pnt3f &	ptOnLine2
	)			const

Find closest points between the two lines. Return false if they are parallel, otherwise return true.

Definition at line 122 of file OSGLine.cpp.

References _dir, _pos, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::cross(), osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot(), osg::PointInterface< ValueTypeT, StorageInterfaceT >::isZero(), and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::squareLength().

{
    // Assumes that _dir and line2._dir are valid and normalized

    Vec3f normal=_dir.cross(line2._dir);
    if(normal.isZero()) return false; // Lines are parallel

    Vec3f p0p1=line2._pos-_pos;
    Real32 lengthSqr=normal.squareLength();
    Real32 s=p0p1.cross(line2._dir).dot(normal) / lengthSqr;
    Real32 t=p0p1.cross(      _dir).dot(normal) / lengthSqr;

    ptOnThis =      _pos + s *       _dir;
    ptOnLine2=line2._pos + t * line2._dir;

    return true;
}

Pnt3f Line::getClosestPoint

(

const Pnt3f &

point

)

const

Returns the closest point on the line to the given point.

Definition at line 146 of file OSGLine.cpp.

References _dir, _pos, and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot().

Referenced by distance().

{
    Vec3f vec(point - _pos);

    return _pos + _dir * vec.dot(_dir);
}

Real32 Line::distance

(

const Pnt3f &

point

)

const

Returns the distance of the given point to the line.

Definition at line 157 of file OSGLine.cpp.

References getClosestPoint().

{
    return (point - getClosestPoint(point)).length();
}

const Pnt3f & osg::Line::getPosition

(

void

)

const [inline]

Accessors for position

Definition at line 52 of file OSGLine.inl.

References _pos.

Referenced by osg::Navigator::buttonRelease(), osg::Navigator::calcDeltas(), osg::IntersectAction::getHitPoint(), osg::Navigator::getIntersectionPoint(), osg::Plane::intersect(), osg::Transform::intersectEnter(), osg::ScreenGroup::intersectEnter(), osg::InverseTransform::intersectEnter(), osg::Billboard::intersectEnter(), osg::Plane::intersectInfinite(), osg::Transform::intersectLeave(), osg::ScreenGroup::intersectLeave(), osg::InverseTransform::intersectLeave(), and osg::Billboard::intersectLeave().

{
    return _pos;
}

const Vec3f & osg::Line::getDirection

(

void

)

const [inline]

Accessors for direction

Definition at line 61 of file OSGLine.inl.

References _dir.

Referenced by osg::Navigator::buttonRelease(), osg::Navigator::calcDeltas(), osg::IntersectAction::getHitPoint(), osg::Navigator::getIntersectionPoint(), osg::Plane::intersect(), osg::Transform::intersectEnter(), osg::ScreenGroup::intersectEnter(), osg::InverseTransform::intersectEnter(), osg::Billboard::intersectEnter(), osg::Plane::intersectInfinite(), osg::Transform::intersectLeave(), osg::ScreenGroup::intersectLeave(), osg::InverseTransform::intersectLeave(), and osg::Billboard::intersectLeave().

{
    return _dir;
}

bool Line::intersect

(

const SphereVolume &

sphere

)

const

Intersect the Line with a Sphere

Definition at line 168 of file OSGLine.cpp.

Referenced by osg::SphereVolume::intersect(), intersect(), osg::Geometry::intersect(), osg::FrustumVolume::intersect(), osg::CylinderVolume::intersect(), and osg::BoxVolume::intersect().

{
    Real32 ent;
    Real32 ex;

    return this->intersect(sphere, ent, ex);
}

bool Line::intersect	(	const SphereVolume &	sphere,
		Real32 &	enter,
		Real32 &	exit
	)			const

Intersect the line with a sphere, returns points of intersection

Definition at line 179 of file OSGLine.cpp.

References _dir, _pos, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot(), osg::Eps, osg::SphereVolume::getCenter(), osg::SphereVolume::getRadius(), and osg::osgsqrt().

{

    Vec3f v;
    Pnt3f center;

    sphere.getCenter(center);

    Real32 radius;
    Real32 h;
    Real32 b;
    Real32 d;
    Real32 t1;
    Real32 t2;

    radius = sphere.getRadius();

    v = center - _pos;

    h = (v.dot(v))-(radius*radius);
    b = (v.dot(_dir));

    if(h >= 0 && b <= 0)
        return false;

    d = b * b - h;

    if(d < 0)
        return false;

    d  = osgsqrt(d);
    t1 = b - d;

//    if (t1 > 1)
//        return false;

    t2 = b + d;

    if( t1 < Eps )
    {
        if( t2 < Eps /*|| t2 > 1*/)
        {
            return false;
        }
    }

    enter = t1;
    exit  = t2;

    return true;
}

bool Line::intersect

(

const CylinderVolume &

cyl

)

const

Intersect the line with a cylinder

Definition at line 236 of file OSGLine.cpp.

References intersect().

{
    Real32 ent;
    Real32 ex;

    return this->intersect(cyl, ent, ex);
}

bool Line::intersect	(	const CylinderVolume &	cyl,
		Real32 &	enter,
		Real32 &	exit
	)			const

Intersect the line with a cylinder, returns points of intersection based on GGems IV

Definition at line 248 of file OSGLine.cpp.

References _dir, _pos, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::cross(), osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot(), osg::CylinderVolume::getAxis(), osg::CylinderVolume::getRadius(), osg::Inf, osg::Plane::intersect(), osg::Plane::isInHalfSpace(), osg::VectorInterface< ValueTypeT, StorageInterfaceT >::length(), osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize(), osg::osgabs(), and osg::osgsqrt().

{
    Real32 radius = cyl.getRadius();

    Vec3f adir;
    Vec3f o_adir;
    Pnt3f apos;

    cyl.getAxis(apos, adir);

    o_adir = adir;
    adir.normalize();

    bool isect;

    Real32 ln;
    Real32 dl;
    Vec3f  RC;
    Vec3f  n;
    Vec3f  D;

    RC = _pos - apos;

    n  = _dir.cross (adir);
    ln =  n  .length(    );

    if(ln == 0)    // IntersectionLine is parallel to CylinderAxis
    {
        D  = RC - (RC.dot(adir)) * adir;
        dl = D.length();

        if(dl <= radius)   // line lies in cylinder
        {
            enter = 0;
            exit  = Inf;
        }
        else
        {
            return false;
        }
    }
    else
    {
        n.normalize();

        dl    = osgabs(RC.dot(n));        //shortest distance
        isect = (dl <= radius);

        if(isect)
        {                 // if ray hits cylinder
            Real32 t;
            Real32 s;
            Vec3f  O;

            O = RC.cross(adir);
            t = - (O.dot(n)) / ln;
            O = n.cross(adir);

            O.normalize();

            s = osgabs (
                (osgsqrt ((radius * radius) - (dl * dl))) / (_dir.dot(O)));

            exit = t + s;

            if(exit < 0)
                return false;

            enter = t - s;

            if(enter < 0)
                enter = 0;
        }
        else
        {
            return false;
        }
    }

    Real32 t;

    Plane bottom(-adir, apos);

    if(bottom.intersect(*this, t))
    {
        if(bottom.isInHalfSpace(_pos))
        {
            if(t > enter) 
                enter = t;
        }
        else
        {
            if(t < exit) 
                exit = t;
        }
    }
    else
    {
        if(bottom.isInHalfSpace(_pos))
            return false;
    }
    
    Plane top(adir, apos + o_adir);

    if(top.intersect(*this, t))
    {
        if(top.isInHalfSpace(_pos))
        {
            if(t > enter)
                enter = t;
        }
        else
        {
            if(t < exit)
                exit = t;
        }
    }
    else
    {
        if(top.isInHalfSpace(_pos))
            return false;
    }

    return (enter < exit);
}

bool Line::intersect

(

const FrustumVolume &

frustum

)

const

Intersect the line with a frustum

Definition at line 379 of file OSGLine.cpp.

References intersect().

{
    Real32 ent;
    Real32 ex;

    return this->intersect(frustum, ent, ex);
}

bool Line::intersect	(	const FrustumVolume &	frustum,
		Real32 &	enter,
		Real32 &	exit
	)			const

Intersect the line with a frustum, returns points of intersection based on Cyrus Beck Algorithm for clipping a line segment to a convex volume.

Definition at line 409 of file OSGLine.cpp.

References _dir, _pos, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot(), osg::Plane::getNormal(), osg::FrustumVolume::getPlanes(), and osg::Plane::intersect().

{
    const Real32 inf = 2 << 16;

    Pnt3f enter_point = _pos + _dir * 0;
    Pnt3f exit_point  = _pos + _dir * inf;

    face faces[6];

    const Plane *planes = frustum.getPlanes();

    Line lines[2];

    //ln[0] - intersection of right and top planes
    planes[3].intersect(planes[4], lines[0]); 

    //ln[1] - left and bottom
    planes[2].intersect(planes[5], lines[1]); 

    Pnt3f pointA;
    Pnt3f pointB;

    if(!planes[0].intersectInfinite(lines[0],pointA))
        std::cout << "This should never happen (A)!!!!";
                    
    if(!planes[1].intersectInfinite(lines[1],pointB))
        std::cout << "This should never happen (B)!!!!";

    faces[0].point        = pointA; 
    faces[0].inner_vector = pointB - pointA;

    faces[1].point        = pointB; 
    faces[1].inner_vector = pointA - pointB;

    faces[2].point        = pointB; 
    faces[2].inner_vector = pointA - pointB;

    faces[3].point        = pointA; 
    faces[3].inner_vector = pointB - pointA;

    faces[4].point        = pointA; 
    faces[4].inner_vector = pointB - pointA;

    faces[5].point        = pointB; 
    faces[5].inner_vector = pointA - pointB;

    for(Int32 i = 0; i < 6; i++)
    {
        faces[i].inner_normal=planes[i].getNormal();

        if(faces[i].inner_normal.dot(faces[i].inner_vector) < 0.f)
            faces[i].inner_normal=-faces[i].inner_normal;

        Vec3f test_enp = enter_point - faces[i].point;
        Vec3f test_exp = exit_point  - faces[i].point;

        Real32 value_enp = test_enp.dot(faces[i].inner_normal);
        Real32 value_exp = test_exp.dot(faces[i].inner_normal);

        if(value_enp < 0.f && value_exp < 0.f) 
            return false;

        if(value_enp > 0.f && value_exp < 0.f) 
            planes[i].intersect(*this, exit_point );

        if(value_enp < 0.f && value_exp > 0.f) 
            planes[i].intersect(*this, enter_point);
    }
    
    Real32 a;
    
    if((a = (enter_point - _pos).dot(_dir)) != 0.f)
    {
        enter = (enter_point - _pos).dot(enter_point - _pos) / a;
    }
    else 
    {
        enter = 0.f;
    }

    if((a = (exit_point  - _pos).dot(_dir)) != 0.f)
    {
        exit  = (exit_point  - _pos).dot(exit_point  - _pos) / a;
    }
    else
    {
        enter = 0.f;              
    }

    return true;
}

bool Line::intersect	(	const BoxVolume &	box,
		Real32 &	enter,
		Real32 &	exit
	)			const

Intersect the line with a box, returns points of intersection

Definition at line 507 of file OSGLine.cpp.

References _dir, _pos, osg::Eps, osg::BoxVolume::getBounds(), and osg::Inf.

{
    Pnt3f low;
    Pnt3f high;
    
    box.getBounds(low, high);
    
    Real32 r;
    Real32 te;
    Real32 tl;
    
    Real32 in  = 0.f;
    Real32 out = Inf;
    
    if(_dir[0] > Eps)
    {
        r = 1.f / _dir[0];
    
        te = (low [0] - _pos[0]) * r;
        tl = (high[0] - _pos[0]) * r;
    
        if(tl < out)   
            out = tl;
    
        if(te > in)    
            in  = te;
    }
    else if(_dir[0] < -Eps)
    {
        r = 1.f / _dir[0];
    
        te = (high[0] - _pos[0]) * r;
        tl = (low [0] - _pos[0]) * r;
    
        if(tl < out)   
            out = tl;
    
        if(te > in)    
            in  = te;
    }
    else if(_pos[0] < low[0] || _pos[0] > high[0])
    {
        return false;
    }
    
    if(_dir[1] > Eps)
    {
        r = 1.f / _dir[1];
    
        te = (low [1] - _pos[1]) * r;
        tl = (high[1] - _pos[1]) * r;
    
        if(tl < out)   
            out = tl;
    
        if(te > in)    
            in  = te;
    
        if(in-out >= Eps)
            return false;
    }
    else if(_dir[1] < -Eps)
    {
        r = 1.f / _dir[1];
    
        te = (high[1] - _pos[1]) * r;
        tl = (low [1] - _pos[1]) * r;
    
        if(tl < out)   
            out = tl;
    
        if(te > in)    
            in  = te;
    
        if(in-out >= Eps)
            return false;
    }
    else if(_pos[1] < low[1] || _pos[1] > high[1])
    {
        return false;
    }
    
    if(_dir[2] > Eps)
    {
        r = 1.f / _dir[2];
    
        te = (low [2] - _pos[2]) * r;
        tl = (high[2] - _pos[2]) * r;
    
        if(tl < out)   
            out = tl;
    
        if(te > in)    
            in  = te;
    }
    else if(_dir[2] < -Eps)
    {
        r = 1.f / _dir[2];
    
        te = (high[2] - _pos[2]) * r;
        tl = (low [2] - _pos[2]) * r;
    
        if(tl < out)   
            out = tl;
    
        if(te > in)    
            in  = te;
    }
    else if(_pos[2] < low[2] || _pos[2] > high[2])
    {
        return false;
    }
    
    enter = in;
    exit  = out;
    
    // Eps: count flat boxes as intersected


    // BUGFIXED, was:  

    // return enter-exit < Eps;

    // This got unstable with bbox check of huge planes
    // and if compiled as opt lib (at least with my gcc 4.0.2).
    // However it worked when compiled as dbg lib. 

    // And now something completely different...

    return in-out < Eps;

    // To get you even more confused: It also works if you leave it
    // as "enter-exit" but declare in/out as Real64.

    // Now think about it......and if it is not 42, please tell!
}

bool Line::intersect	(	Real32	angle,
		const BoxVolume &	box
	)			const

Intersect the line with a box.

Definition at line 653 of file OSGLine.cpp.

{
    // TODO
    assert(false);
    return false;
}

bool Line::intersect	(	Real32	angle,
		const Vec3f &	point
	)			const

Intersect the line with a point.

Definition at line 664 of file OSGLine.cpp.

{
    // TODO
    assert(false);
    return false;
}

bool Line::intersect	(	Real32	angle,
		const Vec3f &	v0,
		const Vec3f &	v1,
		Vec3f &	pt
	)			const

Intersect the line with a line.

Definition at line 675 of file OSGLine.cpp.

{
    // TODO
    assert(false);
    return false;
}

bool Line::intersect	(	const Pnt3f &	v0,
		const Pnt3f &	v1,
		const Pnt3f &	v2,
		Real32 &	t,
		Vec3f *	norm = NULL
	)			const

Intersect the line with a triangle.

Definition at line 692 of file OSGLine.cpp.

References _dir, _pos, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::cross(), osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot(), and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize().

{
    // Eps (1E-6f) didn't work with very small geometries!
    static const Real32 sEps = 1E-10f;

    // find vectors for two edges sharing v0.
    Vec3f edge1 = v1 - v0;
    Vec3f edge2 = v2 - v0;

    // begin calculating determinant - also used to calculate U parameter.
    Vec3f pvec = _dir.cross(edge2);

    // if determinant is near zero, ray lies in plane of triangle.
    Real32 det = edge1.dot(pvec);
    Vec3f qvec;

    if(det > sEps)
    {
        // calculate distance from v0 to ray origin.
        Vec3f tvec = _pos - v0;

        // calculate U parameter and test bounds.
        Real32 u = tvec.dot(pvec);

        if(u < 0.0 || u > det)
            return false;

        // prepare to test V parameter.
        qvec = tvec.cross(edge1);

        // calculate V parameter and test bounds.
        Real32 v = _dir.dot(qvec);

        if(v < 0.0 || u + v > det)
            return false;
    }
    else if(det < -sEps)
    {
        // calculate distance from v0 to ray origin.
        Vec3f tvec = _pos - v0;

        // calculate U parameter and test bounds.
        Real32 u = tvec.dot(pvec);

        if(u > 0.0 || u < det)
            return false;

        // prepare to test V parameter.
        qvec = tvec.cross(edge1);

        // calculate V parameter and test bounds.
        Real32 v = _dir.dot(qvec);

        if(v > 0.0 || u + v < det)
            return false;
    }
    else
        return false;  // ray is parallel to the plane of the triangle.

    Real32 inv_det = 1.0 / det;

    // calculate t, ray intersects triangle.
    t = edge2.dot(qvec) * inv_det;

    if(norm != NULL)
    {
        *norm = edge1.cross(edge2);
        norm->normalize();
    }
    
    return true;
}

---

Member Data Documentation

Pnt3f osg::Line::_pos [private]

Definition at line 143 of file OSGLine.h.

Referenced by getClosestPoint(), getClosestPoints(), getPosition(), intersect(), and setValue().

Vec3f osg::Line::_dir [private]

Definition at line 144 of file OSGLine.h.

Referenced by getClosestPoint(), getClosestPoints(), getDirection(), intersect(), and setValue().

---

The documentation for this class was generated from the following files:

• OSGLine.h
• OSGLine.cpp
• OSGLine.inl