Point3.h

// Copyright (C) Geom Software e.U, Bernhard Kornberger, Graz/Austria
//
// This file is part of the WOF software. WOF is commercial software.
// Users holding a license may use this file in accordance with the
// License Agreement.
//
// This software is provided AS IS with NO WARRANTY OF ANY KIND,
// INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE.
//
// Please contact the author if any conditions of this licensing are
// not clear to you.
//
// Author: Bernhard Kornberger, bkorn (at) geom.at
// http://www.geom.at
 
 
#pragma once
 
#include <math.h>
#include "Vector3.h"
#include <sstream>
namespace GEOM_WOF {
 
 
class Triangle2; // FWD
 
class CLASS_DECLSPEC Point3
{
public:
 
Point3(const double x_,const double y_,const double z_):
    coordX(x_),
    coordY(y_),
    coordZ(z_),
    r(0),g(0),b(0),a(0),bHasColor(false)
{
}
 
Point3(const double x_,const double y_,const double z_,unsigned  char r_,unsigned  char g_,unsigned  char b_,unsigned  char a_):
    coordX(x_),
    coordY(y_),
    coordZ(z_),
    r(r_),
    g(g_),
    b(b_),
    a(a_),
    bHasColor(true)
{
}
 
 
Point3():coordX(0),coordY(0),coordZ(0),r(0),g(0),b(0),a(0),bHasColor(false)
{
}
 
 
Point3(const Point3& p_):
    coordX(p_.coordX),
    coordY(p_.coordY),
    coordZ(p_.coordZ),
    r(p_.r),g(p_.g),b(p_.b),a(p_.a),bHasColor(p_.bHasColor)
{
}
 
Point3 &operator=(const Point3& other)
{
    coordX=other.x();
    coordY=other.y();
    coordZ=other.z();
    r=other.r;
    g=other.g;
    b=other.b;
    a=other.a;
    bHasColor=other.bHasColor;
    return *this;
}
 
~Point3()
{
}
 
void setColor(unsigned  char r_,unsigned  char g_,unsigned  char b_,unsigned  char a_)
{
    r=r_;
    g=g_;
    b=b_;
    a=a_;
    bHasColor=true;
}
 
 
 
void getColor_255(unsigned char& r_,unsigned char& g_,unsigned char& b_,unsigned char& a_) const
{
    r_=r;
    g_=g;
    b_=b;
    a_=a;
}
 
 
void getColor_255(float& r_,float& g_,float& b_,float& a_) const
{
    r_=static_cast<float>(r);
    g_=static_cast<float>(g);
    b_=static_cast<float>(b);
    a_=static_cast<float>(a);
}
 
std::string getColorString()
{
    float r,g,b,a;
    getColor_1(r,g,b,a);
    std::stringstream ss;
    ss<<r<<" "<<g<<" "<<b<<" "<<a;
    return ss.str();
}
 
void getColor_1(float& r_,float& g_,float& b_,float& a_) const
{
    r_=r/255.0f;
    g_=g/255.0f;
    b_=b/255.0f;
    a_=a/255.0f;
}
bool hasColor() const
{
    return bHasColor;
}
 
double x() const
{
    return coordX;
}
 
 
double y() const
{
    return coordY;
}
 
 
double z() const
{
    return coordZ;
}
 
 
void xyz(double& x_,double& y_,double& z_) const
{
    x_=coordX;
    y_=coordY;
    z_=coordZ;
}
 
 
 
inline void addOwnCoords(double& x,double& y,double& z) const
{
    x+=coordX;
    y+=coordY;
    z+=coordZ;
}
 
inline void addOwnCoordsW(double& x,double& y,double& z,double w) const
{
    x+=w*coordX;
    y+=w*coordY;
    z+=w*coordZ;
}
 
// Internal use: add the point's color to r_,g_,b_,a_
inline void addOwnColor(float& r_,float& g_,float& b_,float& a_) const
{
    r_+=float(r);
    g_+=float(g);
    b_+=float(b);
    a_+=float(a);
}
 
// Internal use: add the point's color to r_,g_,b_,a_
inline void addOwnColorW(float w,float& r_,float& g_,float& b_,float& a_) const
{
    r_+=w*float(r);
    g_+=w*float(g);
    b_+=w*float(b);
    a_+=w*float(a);
}
 
 
inline void copyColorFrom(const Point3& other)
{
    r=other.r;
    g=other.g;
    b=other.b;
    a=other.a;
    bHasColor=other.bHasColor;
}
 
 
inline void copyColorFrom(const Point3& other0,const Point3& other1)
{
    if(other0.hasColor() && other1.hasColor())
    {
        r=static_cast<unsigned char>(.5*(float(other0.r)+float(other1.r))+.5f);
        g=static_cast<unsigned char>(.5*(float(other0.g)+float(other1.g))+.5f);
        b=static_cast<unsigned char>(.5*(float(other0.b)+float(other1.b))+.5f);
        a=static_cast<unsigned char>(.5*(float(other0.a+other1.a))+.5f);
        bHasColor=true;
        return;
    }
    if(other0.hasColor())
    {
        copyColorFrom(other0);
        return;
    }
    if(other1.hasColor())
    {
        copyColorFrom(other0);
        return;
    }
    bHasColor=false;
}
 
inline void addWeightedOwnCoords(double weight,double& x,double& y,double& z) const
{
    x+=(weight*coordX);
    y+=(weight*coordY);
    z+=(weight*coordZ);
}
 
    bool operator<(const Point3& p) const
    {
        if(coordX<p.coordX) return true;
        if(coordX>p.coordX) return false;
        if(coordY<p.coordY) return true;
        if(coordY>p.coordY) return false;
        return coordZ<p.coordZ;
    }
 
    bool operator>(const Point3& p) const
    {
        if(coordX>p.coordX) return true;
        if(coordX<p.coordX) return false;
        if(coordY>p.coordY) return true;
        if(coordY<p.coordY) return false;
        return coordY>p.coordY;
    }
    bool operator==(const Point3& p) const
    {
        if(coordX==p.coordX && coordY==p.coordY && coordZ==p.coordZ) return true;
        return false;
    }
bool operator!=(const Point3& p) const
{
    return (coordX!=p.coordX || coordY!=p.coordY || coordZ!=p.coordZ);
}
 
 
void set(const double x_,const double y_,const double z_)
{
    coordX=x_;
    coordY=y_;
    coordZ=z_;
}
 
void set(const Point3& pnt)
{
    coordX=pnt.x();
    coordY=pnt.y();
    coordZ=pnt.z();
}
 
 
 
 
Vector3 operator-(const Point3& other) const
{
    double xdiff(x()-other.x());
    double ydiff(y()-other.y());
    double zdiff(z()-other.z());
    return Vector3(xdiff,ydiff,zdiff);
}
 
Point3 operator+(const Vector3& vec) const
{
    return Point3(x()+vec.x(),y()+vec.y(),z()+vec.z());
}
 
 
Point3 operator-(const Vector3& vec) const
{
    return Point3(x()-vec.x(),y()-vec.y(),z()-vec.z());
}
 
 
friend std::ostream &operator<<(std::ostream &stream, const Point3& pnt);
friend std::istream &operator>>(std::istream &stream, Point3& pnt);
 
 
protected:
    double coordX;
    double coordY;
    double coordZ;
public:
    unsigned char r,g,b,a; // Color 0-255
    bool bHasColor;
};
 
 
 
 
 
 
 
 
// Free functions
inline std::ostream &operator<<(std::ostream &stream, const Point3& pnt)
{
    if(pnt.hasColor())
    {
        stream << "Point3 ("<<&pnt<<"): "<<pnt.x()<<", "<<pnt.y()<<", "<<pnt.z()<<", color("<<int(pnt.r)<<","<<int(pnt.g)<<","<<int(pnt.b)<<","<<int(pnt.a)<<")";
    }
    else
    {
        stream << "Point3 ("<<&pnt<<"): "<<pnt.x()<<", "<<pnt.y()<<", "<<pnt.z()<<", no color";
    }
    return stream;
}
 
inline std::istream &operator>>(std::istream &stream, Point3& pnt)
{
    stream >> pnt.coordX >> pnt.coordY >> pnt.coordZ;
    return stream;
}
 
 
inline double sqDistance(const Point3& p0,const Point3& p1)
{
    double deltaX=p1.x()-p0.x();
    double deltaY=p1.y()-p0.y();
    double deltaZ=p1.z()-p0.z();
    return (deltaX*deltaX+deltaY*deltaY+deltaZ*deltaZ);
}
 
inline double sqDistance(const Point3* p0,const Point3* p1)
{
    double deltaX=p1->x()-p0->x();
    double deltaY=p1->y()-p0->y();
    double deltaZ=p1->z()-p0->z();
    return (deltaX*deltaX+deltaY*deltaY+deltaZ*deltaZ);
}
 
 
inline double distance(const Point3& p0,const Point3& p1)
{
    double deltaX=p1.x()-p0.x();
    double deltaY=p1.y()-p0.y();
    double deltaZ=p1.z()-p0.z();
    return sqrt(deltaX*deltaX+deltaY*deltaY+deltaZ*deltaZ);
}
 
 
inline
Point3 center(const Point3& p0,const Point3& p1)
{
    Point3 center((p0.x()+p1.x())/2.0,(p0.y()+p1.y())/2.0,(p0.z()+p1.z())/2.0);
    return center;
}
 
 
} // (namespace)