TStdPlane.h

// TStdPlane.h: Schnittstelle für die Klasse TStdPlane.
//

#if !defined(AFX_TSTDPLANE_H__C0188075_B26B_4FA6_9558_CDE64117F13D__INCLUDED_)
#define AFX_TSTDPLANE_H__C0188075_B26B_4FA6_9558_CDE64117F13D__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "TKoo3d.h"
#include "TMatrix3D.h"
//#include "TStdLine.h"

template <class T> class TStdLine  
{
protected:
        
        TKoo3d<T> point;
        TKoo3d<T> direction;
public:
        TStdLine(TKoo3d<T>& p, TKoo3d<T>& d)
        {
                point=p;
                direction=d;
        };
        TKoo3d<T> getPoint()
        {
                return point;
        };
        TKoo3d<T> getDir()
        {
                return direction;
        };

        virtual ~TStdLine()
        {
        };
        TKoo3d<T> getNormDistPoint(TKoo3d<T>& k, double* s=NULL);
        

};


template <class T> class TStdPlane  
{
protected:
        

        TKoo3d<T> xAxis;
        TKoo3d<T> yAxis;
        TKoo3d<T> point;
        TKoo3d<T> normV;
        T planeEqParam;
public:

        TStdPlane(TKoo3d<T>& p=TKoo3d<GLfloat>(0,0,0), TKoo3d<T>& nV=TKoo3d<GLfloat>(0,0,1))
        {
                TKoo3d<T> xBuff(10,0,0);
                yAxis=xBuff*nV;
                if (yAxis==TKoo3d<T>(0,0,0))
                {
                        xBuff=TKoo3d<T>(10,10,0);
                        yAxis=xBuff*nV;
                }
                xAxis=nV*yAxis;

                point=p;
                normV=nV;
                planeEqParam=(T)-(normV.vMult(point));
        };

        TStdPlane(TKoo3d<T>& p1, TKoo3d<T>& p2, TKoo3d<T>& p3)
        {
                xAxis=p1-p2;
                yAxis=p3-p2;
                point=p2;
                normV=xAxis*yAxis;
                planeEqParam=(T)-(normV.vMult(point));
        };
        virtual ~TStdPlane()
        {
        };
        template <class A> A getNormDist(TKoo3d<A>& p)
        {

                return (normV.v[0]*p.v[0]+normV.v[1]*p.v[1]+normV.v[2]*p.v[2]+planeEqParam)*(A)(1.0/normV.betrag());
        }
        template <class A> TKoo3d<A> intersect(TStdLine<A>& line)
        {
                TMatrix3D<T> mBuffEins;
                TMatrix3D<T> mBuff;
                TKoo3d<A> retBuff;
                double det;
                
                int i;
                
                for (i=0;i<3;i++)
                {
                        mBuff.v[0][i]=xAxis.v[i];       mBuff.v[1][i]=yAxis.v[i];       mBuff.v[2][i]=-line.getDir().v[i];
                }
                det=mBuff.determinante();
                //x
                for (i=0;i<3;i++)
                {
                        mBuffEins.v[0][i]=(A)line.getPoint().v[i]-point.v[i];   mBuffEins.v[1][i]=yAxis.v[i];   mBuffEins.v[2][i]=-line.getDir().v[i];
                }
                retBuff.v[0]=(A)(mBuffEins.determinante()/det);
                //y
                for (i=0;i<3;i++)
                {
                        mBuffEins.v[0][i]=(A)xAxis.v[i];        mBuffEins.v[1][i]=line.getPoint().v[i]-point.v[i];      mBuffEins.v[2][i]=-line.getDir().v[i];
                }
                
                retBuff.v[1]=(A)(mBuffEins.determinante()/det);
                //v
                for (i=0;i<3;i++)
                {
                        mBuffEins.v[0][i]=(A)xAxis.v[i];        mBuffEins.v[1][i]=yAxis.v[i];   mBuffEins.v[2][i]=line.getPoint().v[i]-point.v[i];
                }
                retBuff.v[2]=(A)(mBuffEins.determinante()/det);
                
                

                return retBuff;
        };
        template <class A> TKoo3d<A> getIntersectPoint(TStdLine<A>& line, double* su=NULL)
        {
                
                
                double s=(-(planeEqParam+normV.vMult(line.getPoint())))/(normV.vMult(line.getDir()));
                if (su)
                        *su=s;
                return line.getPoint()+line.getDir()*(A)s;
        };
        

};


template <class T> TKoo3d<T> TStdLine<T>::getNormDistPoint(TKoo3d<T>& k, double* s)
{
        TStdPlane<T> planeBuff(k,direction);
        
        return planeBuff.getIntersectPoint(*this,s);
}


#endif // !defined(AFX_TSTDPLANE_H__C0188075_B26B_4FA6_9558_CDE64117F13D__INCLUDED_)
 

---