Basic Curves And Surfaces Modeler

// Point3D.cpp: implementation of the CPoint3D class.
//
//////////////////////////////////////////////////////////////////////

#if HAVE_CONFIG_H
#  include <config.h>
#endif

#include "stdafx.h"

#include "Point3D.h"
#include "Vector3D.h"
#include "OneAxis.h"
#include "Line3D.h"
#include "Plane.h"
#include "Matrix33.h"
#include "MMath.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CPoint3D::CPoint3D()
{
    SetParam(0,0,0);
    geomType = CPOINT;
}

CPoint3D::CPoint3D(double x, double y, double z)
{
    SetParam(x, y, z);
    geomType = CPOINT;
}

CPoint3D::~CPoint3D()
{

}

void CPoint3D::SetParam(double x, double y, double z)
{
    itsX=x;
    itsY=y;
    itsZ=z;
}

CPoint3D CPoint3D::operator+(const CPoint3D &newPoint)
{
    return CPoint3D(itsX+newPoint.GetX(),itsY+newPoint.GetY(),itsZ+newPoint.GetZ());
}

CPoint3D CPoint3D::operator+(const double & inc)
{
    return CPoint3D(itsX+inc,itsY+inc,itsZ+inc);
}

CPoint3D CPoint3D::operator-(const CPoint3D &newPoint)
{
    return CPoint3D(itsX-newPoint.GetX(),itsY-newPoint.GetY(),itsZ-newPoint.GetZ());
}

CPoint3D CPoint3D::operator-(const double & dec)
{
    return CPoint3D(itsX-dec,itsY-dec,itsZ-dec);
}

CPoint3D CPoint3D::operator*(const double scale)
{
    return CPoint3D(itsX*scale,itsY*scale,itsZ*scale);
}

CPoint3D CPoint3D::operator/(const double scale)
{
    return CPoint3D(itsX/scale,itsY/scale,itsZ/scale);
}

void CPoint3D::operator+=(const CPoint3D& P)
{
    (*this) = (*this) + P;
}

void CPoint3D::operator+=(const double& inc)
{
    (*this) = (*this) + inc;
}

void CPoint3D::operator-=(const CPoint3D& P)
{
    (*this) = (*this) - P;
}

void CPoint3D::operator-=(const double& dec)
{
    (*this) = (*this) - dec;
}

void CPoint3D::operator*=(const double scale)
{
    (*this) = (*this) * scale;
}

void CPoint3D::operator/=(const double scale)
{
    (*this) = (*this) / scale;
}

CPoint3D CPoint3D::operator = (const CPoint3D& p)
{
    if(this == &p)
	return *this;
    itsX = p.itsX;
    itsY = p.itsY;
    itsZ = p.itsZ;
    return *this;
}

bool CPoint3D::operator == (const CPoint3D& p) const
{
    return (itsX==p.GetX() && itsY==p.GetY() && itsZ==p.GetZ());
}

CPoint3D::operator CVector3D()
{
    CVector3D V((*this));
    return V;
}

double CPoint3D::Distance(const CPoint3D& P) const
{

    double sqad, root;
    double x,y,z,tx,ty,tz;
    x=P.GetX(); y=P.GetY(); z=P.GetZ();
    tx = fabs(this->GetX()-x);
    ty = fabs(this->GetY()-y);
    tz = fabs(this->GetZ()-z);
    sqad=((pow(tx,2))+(pow(ty,2))+(pow(tz,2)));
    root=sqrt(sqad);

    return root;
}

double CPoint3D::Distance(const CPlane& P) const
{

    CPoint3D p = P.GetPosition();
    CPoint3D dp = (*this);
    CVector3D V1 = P.GetDirection();
    CVector3D V2(dp);
    double D = V1.Dot(V2) + P.GetConstant();
    return D;
}

double CPoint3D::PolarAngle(const CPoint3D& P) const
{
    double x = itsX - P.GetX();
    double y = itsY - P.GetY();
    if((x == 0.0) && (y == 0.0))
	return -1;
    if(x == 0.0)
	return ((y > 0.0) ? 90 : 270);
    double theta = atan(y / x);
    theta *= 360.0 / (2 * PI);
    if(x > 0.0)
	return ((y >= 0.0) ? theta : 360 + theta);
    else
	return (180.0 + theta);
}

void CPoint3D::Translate(const COneAxis& Ax, const double& amt)
{
    CGeometry::Translate(Ax, amt);
}

void CPoint3D::Translate(double dx, double dy, double dz)
{
    itsX+=dx;
    itsY+=dy;
    itsZ+=dz;
}

void CPoint3D::Translate(const CVector3D& VDir)
{
    CVector3D V = VDir;
    itsX+=V.GetX();
    itsY+=V.GetY();
    itsZ+=V.GetZ();
}

void CPoint3D::Translate(const CPoint3D& P1, const CPoint3D& P2)
{
    CVector3D V(P1, P2);
    Translate(V);
}

void CPoint3D::Rotate(const COneAxis& Ax, double ang)
{
    COneAxis ax = Ax;
    CVector3D P1 = ax.GetOrigin();
    CVector3D V = ax.GetDirection();
    V.Normalize();
    CMatrix33 M; CVector3D PV(*this);
    M.SetRotation(V, ang);
    CVector3D RV = M*(PV-P1);
    RV = RV + P1;
    *this = RV.Point();
}

void CPoint3D::Scale(const CPoint3D& P, double fact)
{	
    CPoint3D p = P;
    p = p * (1.0 - fact);
    (*this) = (*this)*(fact);
    (*this) = (*this) + p;
}

void CPoint3D::Mirror(const CPoint3D& P)
{
    CPoint3D p = P;
    (*this) *= -1;
    p *= (2.0);
    (*this) += p;
}

void CPoint3D::Mirror(const COneAxis& Ax)
{
    CPoint3D P1 = Ax.GetPosition();
    CPoint3D P = (*this);
    CVector3D N = Ax.GetDirection();
    CLine3D L(P1, N);
    double D = L.Distance(P);
    CVector3D Q = L.NormalThrough(P) * D * (-2.0);
    CVector3D PV((*this));
    CVector3D R = PV + Q;
    this->SetParam(R.GetX(), R.GetY(), R.GetZ());
}

void CPoint3D::Mirror(const CPlane& Pln)
{
    CPlane pln = Pln;
    CPoint3D P = (*this);
    double D = P.Distance(pln);
    CVector3D N = pln.GetDirection().Unit();
    CVector3D Q = N * D * (-2.0);
    CPoint3D QP = Q.Point();
    (*this) = P + QP;
}

CPoint3D CPoint3D::Origin()
{
    return  CPoint3D(0,0,0);
}

std::istream &operator>>(std::istream& input, CPoint3D &p)
{
    input>>p.itsX>>p.itsY>>p.itsZ;
    return input;
}

std::ostream &operator<<(std::ostream& output, CPoint3D &p)
{
    output<< p.itsX << " " << p.itsY << " " << p.itsZ;
    return output;
}