vect4d.cpp

3D reconstruction, medical image processing from colons, using intel image processing for based clas

// Vect4D.cpp : implementation of the CSegRender class
//
#include "stdafx.h"
#include <math.h>
#include "Vect4D.h"


RxVect4D::RxVect4D()
{
	for(int i=0; i<3 ; i++)
		m[i] = 0;

	m[3] =1;
}

RxVect4D::RxVect4D(const RxVect4D& vect)
{
	for(int i=0; i<4 ; i++)
		m[i] = vect.m[i];
}

RxVect4D::RxVect4D(double m0,double m1,double m2,double m3)
{
	m[0]=m0; m[1]=m1; m[2]=m2; m[3]=m3;
}

RxVect4D::RxVect4D(double m0,double m1,double m2)
{
	m[0]=m0; m[1]=m1; m[2]=m2; m[3]=1.;
}

RxVect4D::RxVect4D(double vec[4])
{
	m[0]=vec[0]; m[1]=vec[1]; m[2]=vec[2]; m[3]=vec[3];
}

RxVect4D::RxVect4D(CPoint pt)
{
	m[0]=pt.x; m[1]=pt.y; m[2]=0; m[3]=1;
}

RxVect4D::~RxVect4D(void)
{
}

RxVect4D RxVect4D::operator=(const RxVect4D& vect)
{
	for(int i=0; i<4 ; i++)
		m[i] = vect.m[i];

	return (*this);
}

RxVect4D RxVect4D::operator+(const RxVect4D vect)
{
	RxVect4D resV;

	for(int i=0; i< 3; i++)
		resV.m[i] = m[i]+vect.m[i];
	
	return resV;
}

RxVect4D RxVect4D::operator-(const RxVect4D vect)
{
	RxVect4D resV;

	for(int i=0; i< 3; i++)
		resV.m[i] = m[i]-vect.m[i];
	
	return resV;
}

/*
RxVect4D RxVect4D::operator+(const RxPoint3D<float> pt3D)
{
	RxVect4D resV;

	resV.m[0] = m[0]+pt3D.x;
	resV.m[1] = m[1]+pt3D.y;
	resV.m[2] = m[2]+pt3D.z;
	
	return resV;
}
*/

//vector郴利
double RxVect4D::operator*(const RxVect4D vect)
{
	double res=0;

	for(int i=0; i< 3; i++)
		res += m[i]*vect.m[i];
	
	return res;
}

RxVect4D RxVect4D::operator*(const double var)
{
	RxVect4D resV;

	for(int i=0; i<3; i++)
		resV.m[i] = m[i]*var;
	
	return resV;
}


RxVect4D RxVect4D::Min(const RxVect4D& vect)
{
	RxVect4D resV;
	for(int i=0; i<4; i++)
		resV.m[i] = __min(m[i], vect.m[i]);

	return resV;
}

RxVect4D RxVect4D::Max(const RxVect4D& vect)
{
	RxVect4D resV;
	for(int i=0; i<4; i++)
		resV.m[i] = __max(m[i], vect.m[i]);

	return resV;
}

/*RxVect4D RxVect4D::operator*(const RxMatrix4D mat)
{
	RxVect4D resV(0,0,0,0);

	for(int i=0; i< 4; i++)
		for(int j=0; j< 4; j++) 
			resV.m[i] += m[j]*mat.m[j][i];
	
	return resV;
}*/

double RxVect4D::operator[](const int inx) const
{
	return m[inx];
}

BOOL RxVect4D::operator==(const RxVect4D &r) const
{
	if (m[0]==r[0]&&m[1]==r[1]&&m[2]==r[2]) return TRUE;
	else return FALSE;
}

BOOL RxVect4D::operator!=(const RxVect4D &r) const
{
	return !(*this==r);
}

void RxVect4D::Normalize(void)
{
	double norm = sqrt(m[0]*m[0] + m[1]*m[1] + m[2]*m[2]);

	for(int i=0 ; i<3 ; i++)
		m[i] /= norm;
}


// sungeui start
double RxVect4D::DotProduct (const RxVect4D vect)
{
	return m[0]*vect.m[0] + m[1]*vect.m[1] + m[2]*vect.m[2];
}

RxVect4D RxVect4D::CrossProduct (const RxVect4D vect)
{
	RxVect4D resV;

	resV.m[0] = m[1]*vect.m[2] - m[2]*vect.m[1];
	resV.m[1] = m[2]*vect.m[0] - m[0]*vect.m[2];
	resV.m[2] = m[0]*vect.m[1] - m[1]*vect.m[0];

	return resV;
}

RxVect4D RxVect4D::operator/(const double var)
{
	RxVect4D resV;

	for(int i=0; i<3; i++)
		resV.m[i] = m[i]/var;
	
	return resV;
}
double RxVect4D::Magnitude (void)
{
	double Value;

	Value = m[0] * m[0] + m[1] * m[1] + m[2] * m[2];

	return sqrt(Value);
}

void RxVect4D::Inverse()
{
	m[0] = -m[0];
	m[1] = -m[1];
	m[2] = -m[2];
}

// 0 : X_AXIS, 1 : Y_AXIS, 2 : Z_AXIS
int RxVect4D::GetPrincipalAxis()
{
	if (fabs(m[0]) >= fabs(m[1])) {
		if (fabs(m[0]) >= fabs(m[2]))
			return 0;
		else
			return 2;
	}
	else {
		if (fabs(m[1]) >= fabs(m[2]))
			return 1;
		else
			return 2;
	}
}

int RxVect4D::GetLeastPrincipalAxis()
{
	if (fabs(m[0]) < fabs(m[1])) {
		if (fabs(m[0]) < fabs(m[2]))
			return 0;
		else
			return 2;
	}
	else {
		if (fabs(m[1]) < fabs(m[2]))
			return 1;
		else
			return 2;
	}

}

int RxVect4D::GetPrincipalAxisWithSign()
{
	// 1 : X_AXIS, 2 : Y_AXIS, 3 : Z_AXIS

	if (fabs(m[0]) >= fabs(m[1])-0.1e-3) {
		if (fabs(m[0]) >= fabs(m[2])-0.1e-3) {
			if (m[0] >=0)
				return 1;
			else
				return -1;
		}
		else {
			if (m[2] >= 0)
				return 3;
			else
				return -3;
		}
	}
	else {
		if (fabs(m[1]) >= fabs(m[2])-0.1e-3) {
			if (m[1] >= 0)
				return 2;
			else
				return -2;
		}
		else {
			if (m[2] >= 0)
				return 3;
			else
				return -3;
		}
	}
}

int RxVect4D::GetSecondaryAxisWithSign(int iPrincipal)
{
	// 1 : X_AXIS, 2 : Y_AXIS, 3 : Z_AXIS

	if (iPrincipal < 0) iPrincipal = -iPrincipal;

	if (iPrincipal==1) {
		if (fabs(m[1]) >= fabs(m[2])-0.1e-3) {
			if (m[1] >= 0)
				return 2;
			else
				return -2;
		}
		else {
			if (m[2] >= 0)
				return 3;
			else
				return -3;
		}
	}
	else if (iPrincipal==2) {
		if (fabs(m[0]) >= fabs(m[2])-0.1e-3) {
			if (m[0] >= 0)
				return 1;
			else
				return -1;
		}
		else {
			if (m[2] >= 0)
				return 3;
			else
				return -3;
		}
	}
	else {
		if (fabs(m[0]) >= fabs(m[1])-0.1e-3) {
			if (m[0] >= 0)
				return 1;
			else
				return -1;
		}
		else {
			if (m[1] >= 0)
				return 2;
			else
				return -2;
		}
	}
}