Point2.h

Go to the documentation of this file.

// Copyright (C) Geom Software e.U, Bernhard Kornberger, Graz/Austria
//
// This file is part of the Fade2D library. The student license is free
// of charge and covers personal, non-commercial research. Licensees
// holding a commercial license may use this file in accordance with
// the Commercial 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
// unclear to you.
//
// Support: https://www.geom.at/contact/
// Project: https://www.geom.at/fade2d/html/
 
 
#pragma once
 
#include "common.h"
#include "Vector2.h"
#include <cstring>
 
enum CINC2
{
    CINC2_UNKNOWN,  
    CINC2_ZERO,     
    CINC2_INCIRCLE, 
    CINC2_OUTCIRCLE 
};
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    namespace GEOM_FADE25D {
#elif GEOM_PSEUDO3D==GEOM_FALSE
    namespace GEOM_FADE2D {
#else
    #error GEOM_PSEUDO3D is not defined
#endif
 
 
class Triangle2; // FWD
 
struct VtxColor
{
    VtxColor(unsigned char r_,unsigned char g_,unsigned char b_,unsigned char a_):r(r_),g(g_),b(b_),a(a_)
    {}
    float r,g,b,a;
};
 
 
class CLASS_DECLSPEC Point2
{
#ifdef GEOM_DBG
    int getSeqNum()
    {
        static int seqNum(0);
        return seqNum++;
    }
#endif
 
public:
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    Point2(const double x_,const double y_,const double z_):
        coordX(x_),
        coordY(y_),
        coordZ(z_),
        pAssociatedTriangle(NULL),
        customIndex(-1)
    {
#ifdef GEOM_DBG
        customIndex=getSeqNum();
#endif
    }
 
 
    Point2():coordX(-DBL_MAX),coordY(-DBL_MAX),coordZ(-DBL_MAX),pAssociatedTriangle(NULL),customIndex(-1)
    {
#ifdef GEOM_DBG
        customIndex=getSeqNum();
#endif
    }
    Point2(const Point2& p_):
        coordX(p_.x()),
        coordY(p_.y()),
        coordZ(p_.z()),
        pAssociatedTriangle(NULL),
        customIndex(p_.customIndex)
    {
    }
    Point2 &operator=(const Point2& other)
    {
        coordX=other.x();
        coordY=other.y();
        coordZ=other.z();
        pAssociatedTriangle=NULL;
        customIndex=other.customIndex;
        return *this;
    }
 
    void setZ(double z)
    {
        setHeight(z);
    }
 
    void print()
    {
        GCOUT<<coordX<<" "<<coordY<<" "<<coordZ<<std::endl;
    }
#else
    Point2(const double x_,const double y_):
        coordX(x_),
        coordY(y_),
        pAssociatedTriangle(NULL),
        customIndex(-1)
    {
        //BC("Point2 Constructor default");
    }
    Point2():
        coordX(-DBL_MAX),
        coordY(-DBL_MAX),
        pAssociatedTriangle(NULL),
        customIndex(-1)
    {
    }
    Point2(const Point2& p_):
        coordX(p_.x()),
        coordY(p_.y()),
        pAssociatedTriangle(NULL),
        customIndex(p_.customIndex)
    {
    }
    Point2 &operator=(const Point2& other)
    {
        coordX=other.x();
        coordY=other.y();
        pAssociatedTriangle=NULL;
        customIndex=other.customIndex;
        return *this;
    }
 
    void print()
    {
        GCOUT<<coordX<<" "<<coordY<<std::endl;
    }
#endif
 
    ~Point2()
    {
    }
 
 
    double x() const
    {
        return coordX;
    }
    double y() const
    {
        return coordY;
    }
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    double z() const
    {
        return coordZ;
    }
#endif
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    void xyz(double& x_,double& y_,double& z_) const
    {
        x_=coordX;
        y_=coordY;
        z_=coordZ;
    }
#endif
    void xy(double& x_,double& y_) const
    {
        x_=coordX;
        y_=coordY;
    }
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    void setHeight(double z)
    {
        coordZ=z;
    }
#endif
    double getMaxAbs() const
    {
        double a(fabs(coordX));
        double b(fabs(coordY));
        return (std::max)(a,b);
    }
    bool operator<(const Point2& p) const
    {
        if(coordX<p.coordX) return true;
        if(coordX>p.coordX) return false;
        if(coordY<p.coordY) return true;
        return false;
    }
    bool operator>(const Point2& p) const
    {
        if(coordX>p.coordX) return true;
        if(coordX<p.coordX) return false;
        if(coordY>p.coordY) return true;
        return false;
    }
    bool operator==(const Point2& p) const
    {
        return (coordX==p.coordX && coordY==p.coordY);
    }
#if GEOM_PSEUDO3D==GEOM_TRUE
    bool samePoint(const Point2& p) const
    {
        return(coordX==p.coordX && coordY==p.coordY && coordZ==p.coordZ);
    }
#endif
    bool operator!=(const Point2& p) const
    {
        if(coordX!=p.coordX || coordY!=p.coordY) return true;
        return false;
    }
 
    Triangle2* getIncidentTriangle() const
    {
        return pAssociatedTriangle;
    }
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    void setCoords(const double x_,const double y_,const double z_)
    {
        coordX=x_;
        coordY=y_;
        coordZ=z_;
    }
    void set(const double x_,const double y_,const double z_,int customIndex_)
    {
        coordX=x_;
        coordY=y_;
        coordZ=z_;
        pAssociatedTriangle=NULL;
        customIndex=customIndex_;
#ifdef GEOM_DBG
        customIndex=getSeqNum();
#endif
    }
#else
    void set(const double x_,const double y_,int customIndex_)
    {
        coordX=x_;
        coordY=y_;
        pAssociatedTriangle=NULL;
        customIndex=customIndex_;
#ifdef GEOM_DBG
        customIndex=getSeqNum();
#endif
    }
    void change(const double x_,const double y_)
    {
        coordX=x_;
        coordY=y_;
    }
#endif
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    void set(const Point2& pnt)
    {
        pnt.xyz(coordX,coordY,coordZ);
        pAssociatedTriangle=NULL;
        this->customIndex=pnt.customIndex;
    }
#else
    void set(const Point2& pnt)
    {
        pnt.xy(coordX,coordY);
        pAssociatedTriangle=NULL;
        this->customIndex=pnt.customIndex;
    }
#endif
 
 
 
    void setCustomIndex(int customIndex_)
    {
        customIndex=customIndex_;
    }
    int getCustomIndex() const
    {
        return customIndex;
    }
 
    void setIncidentTriangle(Triangle2* pT)
    {
        pAssociatedTriangle=pT;
    }
 
Vector2 operator-(const Point2& other) const
{
#if GEOM_PSEUDO3D==GEOM_TRUE
    double xdiff(x()-other.x());
    double ydiff(y()-other.y());
    double zdiff(z()-other.z());
    return Vector2(xdiff,ydiff,zdiff);
#else
    double xdiff(x()-other.x());
    double ydiff(y()-other.y());
    return Vector2(xdiff,ydiff);
#endif
 
 
}
 
Point2 operator+(const Vector2& vec) const
{
#if GEOM_PSEUDO3D==GEOM_TRUE
    return Point2(x()+vec.x(),y()+vec.y(),z()+vec.z());
#else
    return Point2(x()+vec.x(),y()+vec.y());
#endif
}
Point2 operator-(const Vector2& vec) const
{
#if GEOM_PSEUDO3D==GEOM_TRUE
    return Point2(x()-vec.x(),y()-vec.y(),z()-vec.z());
#else
    return Point2(x()-vec.x(),y()-vec.y());
#endif
}
friend std::ostream &operator<<(std::ostream &stream, const Point2& pnt);
friend std::istream &operator>>(std::istream &stream, Point2& pnt);
 
protected:
    friend class Dt2;
    double coordX;
    double coordY;
#if GEOM_PSEUDO3D==GEOM_TRUE
    double coordZ;
#endif
    Triangle2* pAssociatedTriangle; 
    int customIndex;
}; // End of class
 
inline std::ostream &operator<<(std::ostream &stream, const Point2& pnt)
{
#if GEOM_PSEUDO3D==GEOM_TRUE
    stream << "Point2 ("<<&pnt<<",ci="<<pnt.customIndex<<"): "<<pnt.x()<<", "<<pnt.y()<<", "<<pnt.z();
    //#ifndef NDEBUG
        //stream<<", anyT="<<pnt.getIncidentTriangle();
    //#endif
#else
    stream << "Point2 ("<<&pnt<<","<<pnt.customIndex<<"): "<<pnt.x()<<", "<<pnt.y();
#endif
 
 
    return stream;
}
 
inline std::istream &operator>>(std::istream &stream, Point2& pnt)
{
#if GEOM_PSEUDO3D==GEOM_TRUE
    stream >> pnt.coordX >> pnt.coordY >> pnt.coordZ;
#else
    stream >> pnt.coordX >> pnt.coordY;
#endif
    return stream;
}
 
// Free functions
 
inline
double sqDistance2D(const Point2& p0,const Point2& p1)
{
    double deltaX=p1.x()-p0.x();
    double deltaY=p1.y()-p0.y();
    return (deltaX*deltaX+deltaY*deltaY);
}
 
 
inline
double sqDistance2D(const double x0,const double y0,const Point2& p1)
{
    double deltaX=p1.x()-x0;
    double deltaY=p1.y()-y0;
    return (deltaX*deltaX+deltaY*deltaY);
}
 
#if GEOM_PSEUDO3D==GEOM_TRUE
 
inline
double sqDistance25D(const Point2& p0,const Point2& p1)
{
    double deltaX=p1.x()-p0.x();
    double deltaY=p1.y()-p0.y();
    double deltaZ=p1.z()-p0.z();
    double result(deltaX*deltaX+deltaY*deltaY+deltaZ*deltaZ);
 
    if(result!=result)
    {
        GCOUT<<"warning, sqDistance25D, nan value, no distance"<<std::endl;
        GCOUT<<"p0="<<p0<<std::endl;
        GCOUT<<"p1="<<p1<<std::endl;
    }
 
    return result;
}
 
 
inline
double sqDistance25D(const double x0,const double y0,const double z0,const Point2& p1)
{
    double deltaX=p1.x()-x0;
    double deltaY=p1.y()-y0;
    double deltaZ=p1.z()-z0;
    double result(deltaX*deltaX+deltaY*deltaY+deltaZ*deltaZ);
 
    if(result!=result)
    {
        GCOUT<<"warning, sqDistance25D, nan value, no distance"<<std::endl;
        GCOUT<<"x0="<<x0<<", y0="<<y0<<", z0="<<z0<<std::endl;
        GCOUT<<"p1="<<p1<<std::endl;
    }
 
    return result;
 
}
#endif
 
 
inline
Point2 center(const Point2& p0,const Point2& p1)
{
#if GEOM_PSEUDO3D==GEOM_TRUE
    Point2 center((p0.x()+p1.x())/2.0,(p0.y()+p1.y())/2.0,(p0.z()+p1.z())/2.0);
 
#else
    Point2 center((p0.x()+p1.x())/2.0,(p0.y()+p1.y())/2.0);
#endif
    return center;
}
 
CLASS_DECLSPEC
Point2 centerWithShift(const Point2& p0,const Point2& p1);
 
#if GEOM_PSEUDO3D==GEOM_TRUE
struct CLASS_DECLSPEC Func_ltPointXYZ
{
    bool operator()(const Point2& p0,const Point2& p1) const
    {
        if(p0.x()<p1.x()) return true;
        if(p0.x()>p1.x()) return false;
        if(p0.y()<p1.y()) return true;
        if(p0.y()>p1.y()) return false;
        return p0.z()<p1.z();
    }
};
struct CLASS_DECLSPEC Func_samePointXYZ
{
    bool operator()(const Point2& p0,const Point2& p1) const
    {
        return p0.x()==p1.x() && p0.y()==p1.y() && p0.z()==p1.z();
    }
};
#endif
 
} // (namespace)