//                            - ANGLE.CPP -
//
//   Implementation of the geometric conception "angle".
//
//   Author: Zhang Lei
//   Date:   1999. 1. 12
//
#include "stdafx.h"
#include "const.h"
#include "paintobj.h"
#include "Pnt.h"
#include <math.h>


double CAngle::m_fReso = pi/180;     // Default resolution is 1 degree.

//////////////////////////////////////////////////////////////////////////////
//   Implementation of class "CAngle".
     
//
//   CAngle: The constructor.
//
CAngle::CAngle(double fValue, int nMode)
{
	// Convert into radian if neccessary
	m_fRad = (nMode == IN_RADIAN) ? fValue : ToRadian(fValue);

	// Normalize the angle
	m_fRad = NormAngle(m_fRad);
}

//
//    Degree: Get the angle value in "degree".
//
double CAngle::Degree()
{
	return ToDegree(m_fRad);
}

//
//    Quadrant: Return the angle's Quadrant. (1/2/3/4).
//
int CAngle::Quadrant()
{
	if (m_fRad < PI/2)                    // Quadrant 1
      return 1;
	else if (m_fRad < PI)                 // Quadrant 2
      return 2;
	else if (m_fRad < 3*PI/2)             // Quadrant 3
      return 3;
   else                                  // Quadrant 4
      return 4;
}

//
//   ToRadian: Convert a degree angle into a radian value.
//
double CAngle::ToRadian(double fDeg)
{
   return (PI/180) * fDeg;
}

//
//   ToDegree: Convert a radian angle into a degree value.
//
double CAngle::ToDegree(double fRad)
{
   return (180/PI) * fRad;
}

//
//    NormAngle: Normalize an radian angle into the range [0, 2*PI).
//
double CAngle::NormAngle(double fRad)
{
   // Scale the angle into [0, +)
   while(fRad < 0)
      fRad += 2*PI;

   // Scale the angle into [0, 2*PI)
   while (fRad >= 2*PI)
      fRad -= 2*PI;

   return fRad;
}

//
//   SetAngleReso: Set the resolution (in radian) of angle comparison.
//
double CAngle::SetReso(double fReso)
{
	// Save old resolution
	double fTemp = m_fReso;

	// Set new resolution
	m_fReso = fReso;

	// Return the old reso value
	return fTemp;               
}

//
//   Operator "-": Return the negation of the angle.
//
CAngle CAngle::operator -()
{
	return CAngle(-m_fRad);
}

//
//   Operator "!": Return the reverse-directioned angle.
//
CAngle CAngle::operator !()
{
	return CAngle(m_fRad + PI);
}

//
//   Operator "+": Return the sum of 2 angles.
//
CAngle CAngle::operator +(const CAngle& Ang)
{
	return CAngle(m_fRad + Ang.m_fRad);
}

//
//   Operator "-": Return the difference of 2 angles.
//
CAngle CAngle::operator -(const CAngle& Ang)
{
	return CAngle(m_fRad - Ang.m_fRad);
}

//
//   Operator "+=": Increment of angle.
//
void CAngle::operator +=(const CAngle& Ang)
{
	m_fRad = NormAngle(m_fRad + Ang.m_fRad);
}

//
//   Operator "-=": Decrement of angle.
//
void CAngle::operator -=(const CAngle& Ang)
{
	m_fRad = NormAngle(m_fRad - Ang.m_fRad);
}

//
//   Operator "==": Test if the 2 given angles are equal.
//
//   NOTE: 
//      If the difference of the 2 angles is less than the "resolution",
//   the 2 angles will be regarded as equal.
//
BOOL CAngle::operator ==(const CAngle& Ang)
{
	double fTemp = (double)fabs(m_fRad - Ang.m_fRad);
	return (fTemp < m_fReso || 2*PI - fTemp < m_fReso);
}

//
//   Operator "!=": Test if the 2 given angles are not equal.
//    
BOOL CAngle::operator !=(const CAngle& Ang)
{
   return !(*this == Ang);
}

//
//   Operator ">": Test if the first angle is bigger than the second one.
//
BOOL CAngle::operator >(const CAngle& Ang)
{
	return ((m_fRad > Ang.m_fRad) && (*this != Ang));
}

//
//    Operator "<": Test if the first angle is smaller than the second one.
//
BOOL CAngle::operator <(const CAngle& Ang)
{
	return ((m_fRad < Ang.m_fRad) && (*this != Ang));
}

//
//   Operator ">=": Test if the first angle is bigger than or equal to
//   the second one.
//
BOOL CAngle::operator >=(const CAngle& Ang)
{
	return ((m_fRad > Ang.m_fRad) || (*this == Ang));
}

//
//   Operator "<=": Test if the first angle is smaller than or equal to
//   the second one.
//
BOOL CAngle::operator <=(const CAngle& Ang)
{
	return ((m_fRad < Ang.m_fRad) || (*this == Ang));
}