Triangle2.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
// not clear to you.
//
// Author: Bernhard Kornberger, bkorn (at) geom.at
// http://www.geom.at
 
#pragma once
#include "Point2.h"
 
 
 
#include "common.h"
#if GEOM_PSEUDO3D==GEOM_TRUE
    namespace GEOM_FADE25D {
#elif GEOM_PSEUDO3D==GEOM_FALSE
    namespace GEOM_FADE2D {
#else
    #error GEOM_PSEUDO3D is not defined
#endif
 
enum CircumcenterQuality
{
    CCQ_INIT, 
    CCQ_INEXACT,  
    CCQ_EXACT, 
    CCQ_OUT_OF_BOUNDS 
};
 
class CLASS_DECLSPEC  Triangle2
{
public:
    Triangle2()
    {
        aVertexPointer[0]=NULL;
        aVertexPointer[1]=NULL;
        aVertexPointer[2]=NULL;
        aOppTriangles[0]=NULL;
        aOppTriangles[1]=NULL;
        aOppTriangles[2]=NULL;
 
    } // Never used!
 
    void getCorners(Point2*& p0,Point2*& p1,Point2*& p2) const;
 
 
    Point2* getCorner(const int ith) const;
 
/* Get the dual Voronoi vertex - DEPRECATED, but kept for
 * backwards compatibility - see the new method getCircumcenter()
*
* @return a std::pair<Point2,bool>, where the first component is the
* circumcenter of the triangle (i.e., the dual Voronoi vertex) and
* the second component is a boolean value which is normally true to
* indicate the computation is reliable.
*
* @param bForceExact can be used to enforce exact computation with
* multiple-precision arithmetic. By default the computationally
* more expensive multiple-precision arithmetic is only used for
* bad-shaped triangles.
*
*
* \if SECTION_FADE25D
* @note The z-coordinate of the returned point is always 0 but you
* can use Fade_2D::getHeight(..) to determine the height.
* \endif
*
* @attention Attention: The circumcenter of a nearly collinear triangle
* can have coordinates beyond the bounds of floating point arithmetic.
* Fade could compute the circumcenter with multiple-precision artihmetic
* but it could not represent the result as a point with floatingpoint
* coordinates. Thus the involved coordinates are DBL_MAX in such a case
* and the boolean return value is then false.
*
* @note Such extreme numeric cases can easily be avoided by insertion
* of four dummy vertices around the triangulation, e.g., at coordinates
* 10 times larger than the domain of the data points. This will
* automatically restrict the Voronoi diagram of the data points to
* this range.
*/
std::pair<Point2,bool> getDual(bool bForceExact=false) const; // DEPRECATED, see getCircumcenter()
 
Point2 getCircumcenter(CircumcenterQuality& ccq,bool bForceExact=false) const;
 
 
 
    Point2 getBarycenter() const;
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    Vector2 getNormalVector() const;
 
 
 
#endif
 
double getInteriorAngle2D(int ith) const;
 
#if GEOM_PSEUDO3D==GEOM_TRUE
double getInteriorAngle25D(int ith) const;
#endif
 
 
 
    double getArea2D() const;
 
 
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    double getArea25D() const;
#endif
 
 
    Triangle2* getOppositeTriangle(const int ith) const;
 
 
    int getIntraTriangleIndex(const Point2* p) const;
    int getIntraTriangleIndex(const Triangle2* pTriangle) const;
 
    int getIntraTriangleIndex(const Point2* p0,const Point2* p1) const;
 
 
 //*
 //*
 //*  Internal use
//*/
    //bool getState() const;
 
    double getSquaredEdgeLength2D(int ith) const;
 
    double getSquaredEdgeLength(int ith) const; // Deprecated, use getSquaredEdgeLength2D()
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    double getSquaredEdgeLength25D(int ith) const;
#endif
//** \brief Method for internal use
 //*
 //* Internal use
//*/
    //void setState(bool bState_);
    void setOppTriangle(const int ith, Triangle2* pTriangle);
    void setProperties( Point2* pI, Point2* pJ, Point2* pK);
 
    void clearProperties();
 
    void setPropertiesAndOppT(Point2* pI, Point2* pJ, Point2* pK,Triangle2* pNeig0,Triangle2* pNeig1,Triangle2* pNeig2);
 
    void setVertexPointer(const int ith, Point2* pp);
 
    bool hasVertex(const Point2* pVtx) const;
 
    bool hasVertex(const Point2& vtx) const;
 
    bool hasOnEdge(int i,const Point2& q) const;
 
    int getMaxIndex() const;
 
    int getMinIndex() const;
 
    double getMaxSqEdgeLen2D() const;
    void getCommonOffset(double& x,double& y) const;
 
 
    CLASS_DECLSPEC
    friend std::ostream &operator<<(std::ostream &stream, const Triangle2& c);
    friend inline void registerTriangles(Triangle2* fromTriangle,int ith,Triangle2*  toTriangle,int jth);
 
protected:
    double computeArea(double l0,double l1,double l2) const;
    bool getCC_inexact(double avgOffX,double avgOffY,Point2& cc) const;
 
 
    Point2* aVertexPointer[3];
    Triangle2* aOppTriangles[3];
    //bool bState;
};
 
namespace{
inline bool checkRange(int ith)
{
    return (ith==0 || ith==1 || ith==2); // true if ith={0,1,2}
}
 
}
inline Triangle2* Triangle2::getOppositeTriangle(const int ith) const
{
    assert(checkRange(ith));
    return aOppTriangles[ith];
}
 
inline void Triangle2::setOppTriangle(const int ith, Triangle2* pNeig)
{
    assert(checkRange(ith));
    aOppTriangles[ith]=pNeig;
}
 
 
inline int Triangle2::getIntraTriangleIndex(const Point2* p0,const Point2* p1) const
{
    for(int i=0;i<3;++i)
    {
        int ici1((i+1)%3);
        int ici2((i+2)%3);
 
        if( aVertexPointer[ici1]==p0 && aVertexPointer[ici2]==p1) return i;
        if( aVertexPointer[ici1]==p1 && aVertexPointer[ici2]==p0) return i;
    }
 
    std::cout<<"BUG: Triangle2::getIntraTriangleIndex failed for"<<std::endl;// COUTOK
    std::cout<<*p0<<std::endl;// COUTOK
    std::cout<<*p1<<std::endl;// COUTOK
    std::cout<<*this<<std::endl;// COUTOK
    assert(false);
    return -1;
}
 
inline int Triangle2::getIntraTriangleIndex(const Point2* pVtx) const
{
#ifndef NDEBUG
    // Just debug code
    for(int i=0;i<3;++i)
    {
        if(aVertexPointer[i]==pVtx)
        {
            return i;
        }
    }
    assert(false);
#endif
    return ( (aVertexPointer[1]==pVtx) + 2*(aVertexPointer[2]==pVtx));
}
 
 
inline int Triangle2::getIntraTriangleIndex(const Triangle2* pTriangle) const
{
#ifndef NDEBUG
    // Just debug code
    for(int i=0;i<3;++i)
    {
        if(aOppTriangles[i]==pTriangle)
        {
            return i;
        }
    }
    assert(false);
#endif
    return ( (aOppTriangles[1]==pTriangle) + 2*(aOppTriangles[2]==pTriangle));
}
 
 
 
inline Point2* Triangle2::getCorner(const int ith) const
{
    assert(checkRange(ith));
    return aVertexPointer[ith];
}
 
inline void Triangle2::getCorners(Point2*& p0,Point2*& p1,Point2*& p2) const
{
    p0=aVertexPointer[0];
    p1=aVertexPointer[1];
    p2=aVertexPointer[2];
}
 
inline void Triangle2::setVertexPointer(const int ith, Point2* pp)
{
    aVertexPointer[ith]=pp;
}
 
inline void Triangle2::setProperties( Point2* pI, Point2* pJ, Point2* pK)
{
    assert((pI!=NULL && pJ!=NULL && pK!=NULL));
    aVertexPointer[0]=pI;
    aVertexPointer[1]=pJ;
    aVertexPointer[2]=pK;
    pI->setIncidentTriangle(this);
    pJ->setIncidentTriangle(this);
    pK->setIncidentTriangle(this);
    aOppTriangles[0]=NULL;
    aOppTriangles[1]=NULL;
    aOppTriangles[2]=NULL;
}
 
inline void Triangle2::clearProperties()
{
    for(int i=0;i<3;++i)
    {
        aVertexPointer[i]=NULL;
        aOppTriangles[i]=NULL;
    }
}
 
inline void Triangle2::setPropertiesAndOppT(
    Point2* pI, Point2* pJ, Point2* pK,
    Triangle2* pNeig0,Triangle2* pNeig1,Triangle2* pNeig2
    )
{
    assert((pI!=NULL && pJ!=NULL && pK!=NULL));
    aVertexPointer[0]=pI;
    aVertexPointer[1]=pJ;
    aVertexPointer[2]=pK;
    pI->setIncidentTriangle(this);
    pJ->setIncidentTriangle(this);
    pK->setIncidentTriangle(this);
    aOppTriangles[0]=pNeig0;
    aOppTriangles[1]=pNeig1;
    aOppTriangles[2]=pNeig2;
}
 
inline void registerTriangles(Triangle2* pFromT,int ith,Triangle2* pToT,int jth)
{
    assert(checkRange(ith));
    assert(checkRange(jth));
 
    pFromT->aOppTriangles[ith]=pToT;
    pToT->aOppTriangles[jth]=pFromT;
 
}
 
 
 
 
} // (namespace)