www.pudn.com > cad3d.zip > 3DPoint.h

// 3DPoint.h: interface for the C3DPoint class.
//
//////////////////////////////////////////////////////////////////////

#ifndef __3DPoint_h__
#define __3DPoint_h__

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

#include 

#include "defs.h"
#include "Check.h"
#include "stdInclude.h"

#include "3DMath/3DMath.h"
#include "3DMath/MathDefs.h"

class MATH3D_API C3DPoint
{
protected:

	math_real				m_dPt[4];//Point coordinats

public:

	C3DPoint(math_real x = 0, math_real y = 0, math_real z = 0, math_real w = 1);
	C3DPoint(const C3DPoint &other);
	C3DPoint(const math_real *other);
 
	void		Set(math_real x = 0, math_real y = 0, math_real z = 0, math_real w = 1) 
	{ 
		m_dPt[0] = x; m_dPt[1] = y; m_dPt[2] = z; m_dPt[3] = w; 
	} 

	void		Clear();//sets to (0,0,0,0);
	void		SetOrigin();//sets to (0,0,0,1);

	std::string	Dump(bool showMessage = true) const;
	std::string	DumpCoord(int i) const; //dumps specific coordinate 0 <= i <= 3

				math_real&		operator ()(const int i);
				const math_real&	operator ()(const int i) const;

				operator math_real* () {return m_dPt; }
				operator const math_real* () const {return m_dPt; }

	C3DPoint&	operator =  (const C3DPoint& rPt); 
	C3DPoint&	operator =  (const math_real *pPoint);
	bool		operator == (const C3DPoint& rPt) const;

	C3DPoint&	operator += (const C3DPoint& a);
	C3DPoint&	operator -= (const C3DPoint& a);
	C3DPoint&	operator *= (math_real k);
	C3DPoint&	operator /= (math_real k);

	C3DPoint&	Normalize();
	bool		IsNormalized() const;
	bool		IsVector() const;
	bool		IsIncident(const C3DPoint& rPt) const;
	bool		IsNull() const;

	//default class operation - poor performance - copy of the result
	C3DPoint	operator + (const C3DPoint& a) const;
	C3DPoint	operator - (const C3DPoint& a) const;
	C3DPoint	operator * (math_real k) const;
	C3DPoint	operator / (math_real k) const;
	math_real	operator * (const C3DPoint& a) const;
};
 
inline C3DPoint::C3DPoint(math_real x, math_real y, math_real z, math_real w)
{
	m_dPt[0] = x; m_dPt[1] = y; m_dPt[2] = z; m_dPt[3] = w;
}

inline C3DPoint::C3DPoint(const C3DPoint &other)
{
	memcpy(m_dPt,other.m_dPt,sizeof(math_real)*4);
}

//sets to (0,0,0,0)
inline void C3DPoint::Clear()
{
	memset(this, 0, sizeof(C3DPoint) );
}

//sets to (0,0,0,1);
inline void C3DPoint::SetOrigin()
{
	m_dPt[0] = m_dPt[1] = m_dPt[2] = 0;
	m_dPt[3] = 1;
}

inline 	C3DPoint::C3DPoint(const math_real *other)
{ 
	memcpy(m_dPt,other,sizeof(math_real)*4);
}

inline math_real& C3DPoint::operator ()(const int i) 
{
	CHECK(0 <= i);
	CHECK(i <= 3);
	return m_dPt[i];
}

inline 	const math_real&	C3DPoint::operator ()(const int i) const
{
	CHECK(0 <= i);
	CHECK(i <= 3);
	return m_dPt[i];
}
	
inline 	C3DPoint&	C3DPoint::operator += (const C3DPoint& a)
{
	m_dPt[0] += a.m_dPt[0];
	m_dPt[1] += a.m_dPt[1];
	m_dPt[2] += a.m_dPt[2];
	m_dPt[3] += a.m_dPt[3];
	return *this;
} 

inline 	C3DPoint&	C3DPoint::operator -= (const C3DPoint& a)
{
	m_dPt[0] -= a.m_dPt[0];
	m_dPt[1] -= a.m_dPt[1];
	m_dPt[2] -= a.m_dPt[2];
	m_dPt[3] -= a.m_dPt[3];
	return *this;
}

inline 	C3DPoint&	C3DPoint::operator *= (const math_real k)
{
	m_dPt[0] *= k;
	m_dPt[1] *= k;
	m_dPt[2] *= k;
	m_dPt[3] *= k;
	return *this;
}

inline 	C3DPoint&	C3DPoint::operator /= (const math_real k)
{
	CHECK(!IsZero(k));
	return (*this) *= (1/k);
}


inline C3DPoint C3DPoint::operator + (const C3DPoint& a) const
{
	C3DPoint res; 
	res.m_dPt[0] = m_dPt[0] + a.m_dPt[0];
	res.m_dPt[1] = m_dPt[1] + a.m_dPt[1];
	res.m_dPt[2] = m_dPt[2] + a.m_dPt[2];
	res.m_dPt[3] = m_dPt[3] + a.m_dPt[3];
	return res;
}

inline C3DPoint C3DPoint::operator - (const C3DPoint& a) const
{
	C3DPoint res; 
	res.m_dPt[0] = m_dPt[0] - a.m_dPt[0];
	res.m_dPt[1] = m_dPt[1] - a.m_dPt[1];
	res.m_dPt[2] = m_dPt[2] - a.m_dPt[2];
	res.m_dPt[3] = m_dPt[3] - a.m_dPt[3];
	return res;
}

inline C3DPoint C3DPoint::operator * (math_real k)  const
{
	return C3DPoint(k*m_dPt[0], k*m_dPt[1], k*m_dPt[2], k*m_dPt[3]);
}

inline C3DPoint C3DPoint::operator / (math_real k) const 
{
	CHECK(!IsZero(k));

	return C3DPoint( *this*(((math_real)1.0)/k) );
}

inline math_real	C3DPoint::operator * (const C3DPoint& a) const
{
	return (m_dPt[0]*a.m_dPt[0] + m_dPt[1]*a.m_dPt[1] + m_dPt[2]*a.m_dPt[2] + m_dPt[3]*a.m_dPt[3]);
}

inline C3DPoint&	C3DPoint::Normalize() 
{
	CHECK( !IsVector() );
	math_real k = (math_real)1.0/m_dPt[3];
	m_dPt[0] *= k;
	m_dPt[1] *= k;
	m_dPt[2] *= k;
	m_dPt[3] = (math_real)1.0;
	return *this;
}

inline bool C3DPoint::IsNormalized() const
{
	return IsEq(m_dPt[3], (math_real)1.0);
}

inline bool C3DPoint::IsVector() const
{
	return IsZero(m_dPt[3]);
}

inline C3DPoint& C3DPoint::operator =	(const C3DPoint& rPt)
{
	memcpy(m_dPt, rPt.m_dPt , sizeof(math_real)*4); 
	/* 
	m_dPt[0] = rPt.m_dPt[0]; 
	m_dPt[1] = rPt.m_dPt[1]; 
	m_dPt[2] = rPt.m_dPt[2]; 
	m_dPt[3] = rPt.m_dPt[3]; 
	*/ 
	return *this;
}
 
inline C3DPoint& C3DPoint::operator =	(const math_real *pPoint)
{
	memcpy(m_dPt, pPoint, sizeof(math_real)*4);
	return *this;
}

inline bool C3DPoint::operator == (const C3DPoint& rPt) const
{
	if ( IsEq(m_dPt[0], rPt(0)) && IsEq(m_dPt[1], rPt(1)) && 
	     IsEq(m_dPt[2], rPt(2)) && IsEq(m_dPt[3], rPt(3)) )
	{
		return true;
	}
	return false;
}

inline 	bool C3DPoint::IsIncident(const C3DPoint& rPt) const
{
	return C3DPoint(*this).Normalize() == C3DPoint(rPt).Normalize();
}

inline 	bool C3DPoint::IsNull() const
{
	return IsZero(m_dPt[0]) && IsZero(m_dPt[1]) && IsZero(m_dPt[2]) && IsZero(m_dPt[3]);
} 

#endif // __3DPoint_h__