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
// unclear to you.
//
// Support: https://www.geom.at/contact/
// Project: https://www.geom.at/fade2d/html/
 
#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!
 
    Point2* getCorner(const int idx) const;
 
    void getCorners(Point2*& p0,Point2*& p1,Point2*& p2) const;
 
 
 
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 idx) const;
 
#if GEOM_PSEUDO3D==GEOM_TRUE
double getInteriorAngle25D(int idx) const;
#endif
 
    double getArea2D() const;
 
 
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    double getArea25D() const;
#endif
 
    Triangle2* getOppositeTriangle(const int idx) const;
 
 
    int getIntraTriangleIndex(const Point2* pCorner) const;
 
    int getIntraTriangleIndex(const Triangle2* pNeig) const;
 
    int getIntraTriangleIndex(const Point2* p0,const Point2* p1) const;
 
    double getSquaredEdgeLength2D(int idx) const;
 
    double getSquaredEdgeLength(int idx) const; // Deprecated, use getSquaredEdgeLength2D()
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    double getSquaredEdgeLength25D(int idx) const;
#endif
    void setOppTriangle(const int idx, 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 idx, Point2* pVtx);
 
    bool hasVertex(const Point2* pVtx) const;
 
    bool hasVertex(const Point2& q) const;
 
    bool hasOnEdge(int idx,const Point2& q) const;
 
    bool hasOn(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) ||
            (aVertexPointer[ici1]==p1 && aVertexPointer[ici2]==p0) ) return i;
    }
 
    GCOUT<<"BUG: Triangle2::getIntraTriangleIndex failed for"<<std::endl;// COUTOK
    GCOUT<<*p0<<std::endl;// COUTOK
    GCOUT<<*p1<<std::endl;// COUTOK
    GCOUT<<*this<<std::endl;// COUTOK
    assert(false);
    return -1;
}
 
inline int Triangle2::getIntraTriangleIndex(const Point2* pVtx) const
{
#ifndef NDEBUG
    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)