97f515985d
git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@2 fdac6126-5c0c-442c-9429-916003d36597
292 lines
9.6 KiB
C++
292 lines
9.6 KiB
C++
//=============================================================================
|
||
//
|
||
// OpenMesh
|
||
// Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen
|
||
// www.openmesh.org
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
//
|
||
// License
|
||
//
|
||
// This library is free software; you can redistribute it and/or modify it
|
||
// under the terms of the GNU Lesser General Public License as published
|
||
// by the Free Software Foundation, version 2.1.
|
||
//
|
||
// This library 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
|
||
// Lesser General Public License for more details.
|
||
//
|
||
// You should have received a copy of the GNU Lesser General Public
|
||
// License along with this library; if not, write to the Free Software
|
||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
//
|
||
// $Revision: 1802 $
|
||
// $Date: 2008-05-19 11:55:07 +0200 (Mo, 19. Mai 2008) $
|
||
//
|
||
//=============================================================================
|
||
|
||
/** \file ModRoundnessT.hh
|
||
|
||
*/
|
||
|
||
//=============================================================================
|
||
//
|
||
// CLASS ModRoundnessT
|
||
//
|
||
//=============================================================================
|
||
|
||
#ifndef OPENMESH_TOOLS_MODROUNDNESST_HH
|
||
#define OPENMESH_TOOLS_MODROUNDNESST_HH
|
||
|
||
|
||
//== INCLUDES =================================================================
|
||
|
||
#include <OpenMesh/Tools/Decimater/ModBaseT.hh>
|
||
#include <math.h>
|
||
|
||
#if defined(OM_CC_MSVC)
|
||
# define OM_ENABLE_WARNINGS 4244
|
||
# pragma warning(disable : OM_ENABLE_WARNINGS )
|
||
#endif
|
||
|
||
//== NAMESPACE ================================================================
|
||
|
||
namespace OpenMesh { // BEGIN_NS_OPENMESH
|
||
namespace Decimater { // BEGIN_NS_DECIMATER
|
||
|
||
|
||
//== CLASS DEFINITION =========================================================
|
||
|
||
|
||
/** Compute error value based on roundness criteria.
|
||
*/
|
||
template <class DecimaterType>
|
||
class ModRoundnessT : public ModBaseT<DecimaterType>
|
||
{
|
||
public:
|
||
DECIMATING_MODULE( ModRoundnessT, DecimaterType, Roundness );
|
||
|
||
public:
|
||
|
||
// typedefs
|
||
typedef typename Mesh::Point Point;
|
||
typedef typename vector_traits<Point>::value_type value_type;
|
||
|
||
public:
|
||
|
||
/// Constructor
|
||
ModRoundnessT( DecimaterType &_dec ) :
|
||
Base(_dec, false),
|
||
min_r_(-1.0)
|
||
{ }
|
||
|
||
/// Destructor
|
||
~ModRoundnessT() { }
|
||
|
||
public: // inherited
|
||
|
||
/** Compute collapse priority due to roundness of triangle.
|
||
*
|
||
* The roundness is computed by dividing the radius of the
|
||
* circumference by the length of the shortest edge. The result is
|
||
* normalized.
|
||
*
|
||
* \return [0:1] or ILLEGAL_COLLAPSE in non-binary mode
|
||
* \return LEGAL_COLLAPSE or ILLEGAL_COLLAPSE in binary mode
|
||
* \see set_min_roundness()
|
||
*/
|
||
float collapse_priority(const CollapseInfo& _ci)
|
||
{
|
||
// using namespace OpenMesh;
|
||
|
||
typename Mesh::ConstVertexOHalfedgeIter voh_it(Base::mesh(), _ci.v0);
|
||
double r;
|
||
double priority = 0.0; //==LEGAL_COLLAPSE
|
||
typename Mesh::FaceHandle fhC, fhB;
|
||
Vec3f B,C;
|
||
|
||
if ( min_r_ < 0.0 ) // continues mode
|
||
{
|
||
C = vector_cast<Vec3f>(Base::mesh().point( Base::mesh().to_vertex_handle(voh_it)));
|
||
fhC = Base::mesh().face_handle( voh_it.handle() );
|
||
|
||
for (++voh_it; voh_it; ++voh_it)
|
||
{
|
||
B = C;
|
||
fhB = fhC;
|
||
C = vector_cast<Vec3f>(Base::mesh().point(Base::mesh().to_vertex_handle(voh_it)));
|
||
fhC = Base::mesh().face_handle( voh_it.handle() );
|
||
|
||
if ( fhB == _ci.fl || fhB == _ci.fr )
|
||
continue;
|
||
|
||
// simulate collapse using position of v1
|
||
r = roundness( vector_cast<Vec3f>(_ci.p1), B, C );
|
||
|
||
// return the maximum non-roundness
|
||
priority = std::max( priority, (1.0-r) );
|
||
|
||
}
|
||
}
|
||
else // binary mode
|
||
{
|
||
C = vector_cast<Vec3f>(Base::mesh().point( Base::mesh().to_vertex_handle(voh_it)));
|
||
fhC = Base::mesh().face_handle( voh_it.handle() );
|
||
|
||
for (++voh_it; voh_it && (priority==Base::LEGAL_COLLAPSE); ++voh_it)
|
||
{
|
||
B = C;
|
||
fhB = fhC;
|
||
C = vector_cast<Vec3f>(Base::mesh().point(Base::mesh().to_vertex_handle(voh_it)));
|
||
fhC = Base::mesh().face_handle( voh_it.handle() );
|
||
|
||
if ( fhB == _ci.fl || fhB == _ci.fr )
|
||
continue;
|
||
|
||
priority = ( (r=roundness( vector_cast<Vec3f>(_ci.p1), B, C )) < min_r_)
|
||
? Base::ILLEGAL_COLLAPSE
|
||
: Base::LEGAL_COLLAPSE;
|
||
}
|
||
}
|
||
|
||
return (float) priority;
|
||
}
|
||
|
||
|
||
|
||
public: // specific methods
|
||
|
||
void set_min_angle( float _angle, bool /* _binary=true */ )
|
||
{
|
||
assert( _angle > 0 && _angle < 60 );
|
||
|
||
_angle = float(M_PI * _angle /180.0);
|
||
|
||
Vec3f A,B,C;
|
||
|
||
A = Vec3f( 0, 0, 0);
|
||
B = Vec3f( 2*cos(_angle), 0, 0);
|
||
C = Vec3f( cos(_angle), sin(_angle), 0);
|
||
|
||
double r1 = roundness(A,B,C);
|
||
|
||
_angle = float(0.5 * ( M_PI - _angle ));
|
||
|
||
A = Vec3f( 0, 0, 0);
|
||
B = Vec3f( 2*cos(_angle), 0, 0);
|
||
C = Vec3f( cos(_angle), sin(_angle), 0);
|
||
|
||
double r2 = roundness(A,B,C);
|
||
|
||
set_min_roundness( value_type(std::min(r1,r2)), true );
|
||
}
|
||
|
||
/** Set a minimum roundness value.
|
||
* \param _min_roundness in range (0,1)
|
||
* \param _binary Set true, if the binary mode should be enabled,
|
||
* else false. In latter case the collapse_priority()
|
||
* returns a float value if the constrain does not apply
|
||
* and ILLEGAL_COLLAPSE else.
|
||
*/
|
||
void set_min_roundness( value_type _min_roundness, bool _binary=true )
|
||
{
|
||
assert( 0.0 <= _min_roundness && _min_roundness <= 1.0 );
|
||
min_r_ = _min_roundness;
|
||
Base::set_binary(_binary);
|
||
}
|
||
|
||
/// Unset minimum value constraint and enable non-binary mode.
|
||
void unset_min_roundness()
|
||
{
|
||
min_r_ = -1.0;
|
||
Base::set_binary(false);
|
||
}
|
||
|
||
// Compute a normalized roundness of a triangle ABC
|
||
//
|
||
// Having
|
||
// A,B,C corner points of triangle
|
||
// a,b,c the vectors BC,CA,AB
|
||
// Area area of triangle
|
||
//
|
||
// then define
|
||
//
|
||
// radius of circumference
|
||
// R := -----------------------
|
||
// length of shortest edge
|
||
//
|
||
// ||a|| * ||b|| * ||c||
|
||
// ---------------------
|
||
// 4 * Area ||a|| * ||b|| * ||c||
|
||
// = ----------------------- = -----------------------------------
|
||
// min( ||a||,||b||,||c||) 4 * Area * min( ||a||,||b||,||c|| )
|
||
//
|
||
// ||a|| * ||b|| * ||c||
|
||
// = -------------------------------------------------------
|
||
// 4 * 1/2 * ||cross(B-A,C-A)|| * min( ||a||,||b||,||c|| )
|
||
//
|
||
// a'a * b'b * c'c
|
||
// R<> = ----------------------------------------------------------
|
||
// 4 * cross(B-A,C-A)'cross(B-A,C-A) * min( a'a, b'b, c'c )
|
||
//
|
||
// a'a * b'b * c'c
|
||
// R = 1/2 * sqrt(---------------------------)
|
||
// AA * min( a'a, b'b, c'c )
|
||
//
|
||
// At angle 60<36> R has it's minimum for all edge lengths = sqrt(1/3)
|
||
//
|
||
// Define normalized roundness
|
||
//
|
||
// nR := sqrt(1/3) / R
|
||
//
|
||
// AA * min( a'a, b'b, c'c )
|
||
// = sqrt(4/3) * sqrt(---------------------------)
|
||
// a'a * b'b * c'c
|
||
//
|
||
double roundness( const Vec3f& A, const Vec3f& B, const Vec3f &C )
|
||
{
|
||
const value_type epsilon = value_type(1e-15);
|
||
|
||
static const value_type sqrt43 = value_type(sqrt(4.0/3.0)); // 60<36>,a=b=c, **)
|
||
|
||
Vec3f vecAC = C-A;
|
||
Vec3f vecAB = B-A;
|
||
|
||
// compute squared values to avoid sqrt-computations
|
||
value_type aa = (B-C).sqrnorm();
|
||
value_type bb = vecAC.sqrnorm();
|
||
value_type cc = vecAB.sqrnorm();
|
||
value_type AA = cross(vecAC,vecAB).sqrnorm(); // without factor 1/4 **)
|
||
|
||
if ( AA < epsilon )
|
||
return 0.0;
|
||
|
||
double nom = AA * std::min( std::min(aa,bb),cc );
|
||
double denom = aa * bb * cc;
|
||
double nR = sqrt43 * sqrt(nom/denom);
|
||
|
||
return nR;
|
||
}
|
||
|
||
private:
|
||
|
||
value_type min_r_;
|
||
};
|
||
|
||
|
||
//=============================================================================
|
||
} // END_NS_DECIMATER
|
||
} // END_NS_OPENMESH
|
||
//=============================================================================
|
||
#if defined(OM_CC_MSVC) && defined(OM_ENABLE_WARNINGS)
|
||
# pragma warning(default : OM_ENABLE_WARNINGS)
|
||
# undef OM_ENABLE_WARNINGS
|
||
#endif
|
||
//=============================================================================
|
||
#endif // OPENMESH_TOOLS_PROGMESHT_HH defined
|
||
//=============================================================================
|
||
|