190 lines
6.1 KiB
C++
190 lines
6.1 KiB
C++
/*
|
|
* Copyright (C) 1998, 2000-2007, 2010, 2011, 2012, 2013 SINTEF ICT,
|
|
* Applied Mathematics, Norway.
|
|
*
|
|
* Contact information: E-mail: tor.dokken@sintef.no
|
|
* SINTEF ICT, Department of Applied Mathematics,
|
|
* P.O. Box 124 Blindern,
|
|
* 0314 Oslo, Norway.
|
|
*
|
|
* This file is part of TTL.
|
|
*
|
|
* TTL is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* TTL is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public
|
|
* License along with TTL. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*
|
|
* In accordance with Section 7(b) of the GNU Affero General Public
|
|
* License, a covered work must retain the producer line in every data
|
|
* file that is created or manipulated using TTL.
|
|
*
|
|
* Other Usage
|
|
* You can be released from the requirements of the license by purchasing
|
|
* a commercial license. Buying such a license is mandatory as soon as you
|
|
* develop commercial activities involving the TTL library without
|
|
* disclosing the source code of your own applications.
|
|
*
|
|
* This file may be used in accordance with the terms contained in a
|
|
* written agreement between you and SINTEF ICT.
|
|
*/
|
|
|
|
#ifndef _HALF_EDGE_TRAITS_
|
|
#define _HALF_EDGE_TRAITS_
|
|
|
|
#include <ttl/halfedge/hetriang.h>
|
|
#include <ttl/halfedge/hedart.h>
|
|
|
|
namespace hed
|
|
{
|
|
/**
|
|
* \struct TTLtraits
|
|
* \brief \b Traits class (static struct) for the half-edge data structure.
|
|
*
|
|
* The member functions are those required by different function templates
|
|
* in the TTL. Documentation is given here to explain what actions
|
|
* should be carried out on the actual data structure as required by the functions
|
|
* in the \ref ttl namespace.
|
|
*
|
|
* The source code of \c %HeTraits.h shows how the traits class is implemented for the
|
|
* half-edge data structure.
|
|
*
|
|
* \see \ref api
|
|
*/
|
|
struct TTLtraits
|
|
{
|
|
/**
|
|
* The floating point type used in calculations involving scalar products and cross products.
|
|
*/
|
|
typedef double REAL_TYPE;
|
|
|
|
/** @name Geometric Predicates */
|
|
//@{
|
|
/**
|
|
* Scalar product between two 2D vectors represented as darts.\n
|
|
*
|
|
* ttl_util::scalarProduct2d can be used.
|
|
*/
|
|
static REAL_TYPE ScalarProduct2D( const DART& aV1, const DART& aV2 )
|
|
{
|
|
DART v10 = aV1;
|
|
v10.Alpha0();
|
|
|
|
DART v20 = aV2;
|
|
v20.Alpha0();
|
|
|
|
return ttl_util::ScalarProduct2D( v10.X() - aV1.X(), v10.Y() - aV1.Y(),
|
|
v20.X() - aV2.X(), v20.Y() - aV2.Y() );
|
|
}
|
|
|
|
/**
|
|
* Scalar product between two 2D vectors.
|
|
* The first vector is represented by a dart \e v, and the second
|
|
* vector has direction from the source node of \e v to the point \e p.\n
|
|
*
|
|
* ttl_util::ScalarProduct2D can be used.
|
|
*/
|
|
static REAL_TYPE ScalarProduct2D( const DART& aV, const NODE_PTR& aP )
|
|
{
|
|
DART d0 = aV;
|
|
d0.Alpha0();
|
|
|
|
return ttl_util::ScalarProduct2D( d0.X() - aV.X(), d0.Y() - aV.Y(),
|
|
aP->GetX() - aV.X(), aP->GetY() - aV.Y() );
|
|
}
|
|
|
|
/**
|
|
* Cross product between two vectors in the plane represented as darts.
|
|
* The z-component of the cross product is returned.\n
|
|
*
|
|
* ttl_util::CrossProduct2D can be used.
|
|
*/
|
|
static REAL_TYPE CrossProduct2D( const DART& aV1, const DART& aV2 )
|
|
{
|
|
DART v10 = aV1;
|
|
v10.Alpha0();
|
|
|
|
DART v20 = aV2;
|
|
v20.Alpha0();
|
|
|
|
return ttl_util::CrossProduct2D( v10.X() - aV1.X(), v10.Y() - aV1.Y(),
|
|
v20.X() - aV2.X(), v20.Y() - aV2.Y() );
|
|
}
|
|
|
|
/**
|
|
* Cross product between two vectors in the plane.
|
|
* The first vector is represented by a dart \e v, and the second
|
|
* vector has direction from the source node of \e v to the point \e p.
|
|
* The z-component of the cross product is returned.\n
|
|
*
|
|
* ttl_util::CrossProduct2d can be used.
|
|
*/
|
|
static REAL_TYPE CrossProduct2D( const DART& aV, const NODE_PTR& aP )
|
|
{
|
|
DART d0 = aV;
|
|
d0.Alpha0();
|
|
|
|
return ttl_util::CrossProduct2D( d0.X() - aV.X(), d0.Y() - aV.Y(),
|
|
aP->GetX() - aV.X(), aP->GetY() - aV.Y() );
|
|
}
|
|
|
|
/**
|
|
* Let \e n1 and \e n2 be the nodes associated with two darts, and let \e p
|
|
* be a point in the plane. Return a positive value if \e n1, \e n2,
|
|
* and \e p occur in counterclockwise order; a negative value if they occur
|
|
* in clockwise order; and zero if they are collinear.
|
|
*/
|
|
static REAL_TYPE Orient2D( const DART& aN1, const DART& aN2, const NODE_PTR& aP )
|
|
{
|
|
REAL_TYPE pa[2];
|
|
REAL_TYPE pb[2];
|
|
REAL_TYPE pc[2];
|
|
|
|
pa[0] = aN1.X();
|
|
pa[1] = aN1.Y();
|
|
pb[0] = aN2.X();
|
|
pb[1] = aN2.Y();
|
|
pc[0] = aP->GetX();
|
|
pc[1] = aP->GetY();
|
|
|
|
return ttl_util::Orient2DFast( pa, pb, pc );
|
|
}
|
|
|
|
/**
|
|
* This is the same predicate as represented with the function above,
|
|
* but with a slighty different interface:
|
|
* The last parameter is given as a dart where the source node of the dart
|
|
* represents a point in the plane.
|
|
* This function is required for constrained triangulation.
|
|
*/
|
|
static REAL_TYPE Orient2D( const DART& aN1, const DART& aN2, const DART& aP )
|
|
{
|
|
REAL_TYPE pa[2];
|
|
REAL_TYPE pb[2];
|
|
REAL_TYPE pc[2];
|
|
|
|
pa[0] = aN1.X();
|
|
pa[1] = aN1.Y();
|
|
pb[0] = aN2.X();
|
|
pb[1] = aN2.Y();
|
|
pc[0] = aP.X();
|
|
pc[1] = aP.Y();
|
|
|
|
return ttl_util::Orient2DFast( pa, pb, pc );
|
|
}
|
|
|
|
//@} // End of Geometric Predicates Group
|
|
};
|
|
|
|
} // End of hed namespace
|
|
|
|
#endif
|