Commit 34f8ed8b authored by Sylvain Thery's avatar Sylvain Thery

Merge branch 'master' of cgogn:~vanhoey/CGoGN

parents 3db03780 4ae28bc3
......@@ -67,6 +67,7 @@ public:
void updateAfterCollapse(Dart d2, Dart dd2) ;
void updateWithoutCollapse() { }
} ;
template <typename PFP>
......@@ -143,6 +144,24 @@ public:
void updateAfterCollapse(Dart d2, Dart dd2) ;
void updateWithoutCollapse() { }
void getEdgeErrors(EdgeAttribute<typename PFP::REAL> *errors)
{
assert(errors != NULL || !"EdgeSelector::setColorMap requires non null vertexattribute argument") ;
if (!errors->isValid())
std::cerr << "EdgeSelector::setColorMap requires valid edgeattribute argument" << std::endl ;
assert(edgeInfo.isValid()) ;
TraversorE<typename PFP::MAP> travE(this->m_map) ;
for(Dart d = travE.begin() ; d != travE.end() ; d = travE.next())
{
(*errors)[d] = -1 ;
if (edgeInfo[d].valid)
{
(*errors)[d] = edgeInfo[d].it->first ;
}
}
}
} ;
template <typename PFP>
......@@ -518,6 +537,24 @@ public:
void updateAfterCollapse(Dart d2, Dart dd2) ;
void updateWithoutCollapse() { }
void getEdgeErrors(EdgeAttribute<typename PFP::REAL> *errors)
{
assert(errors != NULL || !"EdgeSelector::setColorMap requires non null vertexattribute argument") ;
if (!errors->isValid())
std::cerr << "EdgeSelector::setColorMap requires valid edgeattribute argument" << std::endl ;
assert(edgeInfo.isValid()) ;
TraversorE<typename PFP::MAP> travE(this->m_map) ;
for(Dart d = travE.begin() ; d != travE.end() ; d = travE.next())
{
(*errors)[d] = -1 ;
if (edgeInfo[d].valid)
{
(*errors)[d] = edgeInfo[d].it->first ;
}
}
}
} ;
/*****************************************************************************************************************
......
......@@ -290,6 +290,9 @@ bool EdgeSelector_QEM<PFP>::init()
{
if((*it)->getApproximatedAttributeName() == "position")
{
assert((*it)->getType() != A_hQEM || !"Approximator(hQEM) and selector (EdgeSelector_QEM) are not compatible") ;
assert((*it)->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (EdgeSelector_QEM) are not compatible") ;
assert((*it)->getType() != A_Lightfield || !"Approximator(hLightfield) and selector (EdgeSelector_QEM) are not compatible") ;
m_positionApproximator = reinterpret_cast<Approximator<PFP, VEC3,EDGE>* >(*it) ;
ok = true ;
}
......@@ -507,6 +510,9 @@ bool EdgeSelector_QEMml<PFP>::init()
{
if((*it)->getApproximatedAttributeName() == "position")
{
assert((*it)->getType() != A_hQEM || !"Approximator(hQEM) and selector (EdgeSelector_QEMml) are not compatible") ;
assert((*it)->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (EdgeSelector_QEMml) are not compatible") ;
assert((*it)->getType() != A_Lightfield || !"Approximator(hLightfield) and selector (EdgeSelector_QEMml) are not compatible") ;
m_positionApproximator = reinterpret_cast<Approximator<PFP, VEC3,EDGE>* >(*it) ;
ok = true ;
}
......@@ -737,6 +743,9 @@ bool EdgeSelector_Curvature<PFP>::init()
{
if((*it)->getApproximatedAttributeName() == "position")
{
assert((*it)->getType() != A_hQEM || !"Approximator(hQEM) and selector (EdgeSelector_Curvature) are not compatible") ;
assert((*it)->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (EdgeSelector_Curvature) are not compatible") ;
assert((*it)->getType() != A_Lightfield || !"Approximator(hLightfield) and selector (EdgeSelector_Curvature) are not compatible") ;
m_positionApproximator = reinterpret_cast<Approximator<PFP, VEC3,EDGE>* >(*it) ;
ok = true ;
}
......@@ -948,6 +957,9 @@ bool EdgeSelector_MinDetail<PFP>::init()
{
if((*it)->getApproximatedAttributeName() == "position" && (*it)->getPredictor())
{
assert((*it)->getType() != A_hQEM || !"Approximator(hQEM) and selector (EdgeSelector_MinDetail) are not compatible") ;
assert((*it)->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (EdgeSelector_MinDetail) are not compatible") ;
assert((*it)->getType() != A_Lightfield || !"Approximator(hLightfield) and selector (EdgeSelector_MinDetail) are not compatible") ;
m_positionApproximator = reinterpret_cast<Approximator<PFP, VEC3,EDGE>* >(*it) ;
ok = true ;
}
......@@ -1116,14 +1128,14 @@ bool EdgeSelector_ColorNaive<PFP>::init()
{
MAP& m = this->m_map ;
assert(this->m_approximators[0]->getType() != A_hQEM || !"Approximator(hQEM) and selector (ColorNaive) are not compatible") ;
assert(this->m_approximators[0]->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (ColorNaive) are not compatible") ;
assert(this->m_approximators[0]->getType() != A_Lightfield || !"Approximator(hLightfield) and selector (ColorNaive) are not compatible") ;
// Verify availability of required approximators
unsigned int ok = 0 ;
for (unsigned int approxindex = 0 ; approxindex < this->m_approximators.size() ; ++approxindex)
{
assert(this->m_approximators[approxindex]->getType() != A_hQEM || !"Approximator(hQEM) and selector (ColorNaive) are not compatible") ;
assert(this->m_approximators[approxindex]->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (ColorNaive) are not compatible") ;
assert(this->m_approximators[approxindex]->getType() != A_Lightfield || !"Approximator(hLightfield) and selector (ColorNaive) are not compatible") ;
bool saved = false ;
for (unsigned int attrindex = 0 ; attrindex < this->m_approximators[approxindex]->getNbApproximated() ; ++ attrindex)
{
......@@ -1383,13 +1395,14 @@ bool EdgeSelector_QEMextColor<PFP>::init()
{
MAP& m = this->m_map ;
assert(this->m_approximators[0]->getType() != A_hQEM || !"Approximator(hQEM) and selector (ColorNaive) are not compatible") ;
assert(this->m_approximators[0]->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (ColorNaive) are not compatible") ;
// Verify availability of required approximators
unsigned int ok = 0 ;
for (unsigned int approxindex = 0 ; approxindex < this->m_approximators.size() ; ++approxindex)
{
assert(this->m_approximators[approxindex]->getType() != A_hQEM || !"Approximator(hQEM) and selector (EdgeSelector_QEMextColor) are not compatible") ;
assert(this->m_approximators[approxindex]->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (EdgeSelector_QEMextColor) are not compatible") ;
assert(this->m_approximators[approxindex]->getType() != A_hLightfieldHalf || !"Approximator(hLightfieldHalf) and selector (EdgeSelector_QEMextColor) are not compatible") ;
bool saved = false ;
for (unsigned int attrindex = 0 ; attrindex < this->m_approximators[approxindex]->getNbApproximated() ; ++ attrindex)
{
......@@ -1681,13 +1694,14 @@ bool EdgeSelector_Lightfield<PFP>::init()
{
MAP& m = this->m_map ;
assert(this->m_approximators[0]->getType() != A_hQEM || !"Approximator(hQEM) and selector (ColorNaive) are not compatible") ;
assert(this->m_approximators[0]->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (ColorNaive) are not compatible") ;
// Verify availability of required approximators
unsigned int ok = 0 ;
for (unsigned int approxindex = 0 ; approxindex < this->m_approximators.size() ; ++approxindex)
{
assert(this->m_approximators[approxindex]->getType() != A_hQEM || !"Approximator(hQEM) and selector (EdgeSelector_Lightfield) are not compatible") ;
assert(this->m_approximators[approxindex]->getType() != A_hHalfCollapse || !"Approximator(hHalfCollapse) and selector (EdgeSelector_Lightfield) are not compatible") ;
assert(this->m_approximators[approxindex]->getType() != A_hLightfieldHalf || !"Approximator(hLightfieldHalf) and selector (EdgeSelector_Lightfield) are not compatible") ;
unsigned int k = 0 ;
bool saved = false ;
for (unsigned int attrindex = 0 ; attrindex < this->m_approximators[approxindex]->getNbApproximated() ; ++ attrindex)
......@@ -2004,18 +2018,16 @@ void EdgeSelector_Lightfield<PFP>::computeEdgeInfo(Dart d, EdgeInfo& einfo)
//std::cout << quadGeom(newPos) << " vs " << alpha/M_PI << " vs " << quadHF(newHF) << std::endl ;
// sum of QEM metric and frame orientation difference
const REAL& err =
quadGeom(newPos) // geom
+ alpha / M_PI // frame
+ quadHF(newHF) // function coefficients
;
const REAL& errG = quadGeom(newPos) ; // geom
const REAL& errAngle = alpha / M_PI ; // frame
const REAL& errLF = quadHF(newHF) ; // function coefficients
// Check if errated values appear
if (err < -1e-6)
if (errG < -1e-10 || errAngle < -1e-10 || errLF < -1e-10)
einfo.valid = false ;
else
{
einfo.it = edges.insert(std::make_pair(std::max(err,REAL(0)), d)) ;
einfo.it = edges.insert(std::make_pair(std::max(errG + errAngle + errLF, REAL(0)), d)) ;
einfo.valid = true ;
}
}
......
......@@ -152,6 +152,25 @@ public:
void updateAfterCollapse(Dart d2, Dart dd2) ;
void updateWithoutCollapse() { }
void getEdgeErrors(EdgeAttribute<typename PFP::REAL> *errors)
{
assert(errors != NULL || !"EdgeSelector::setColorMap requires non null vertexattribute argument") ;
if (!errors->isValid())
std::cerr << "EdgeSelector::setColorMap requires valid edgeattribute argument" << std::endl ;
assert(halfEdgeInfo.isValid()) ;
TraversorE<typename PFP::MAP> travE(this->m_map) ;
for(Dart d = travE.begin() ; d != travE.end() ; d = travE.next())
{
if (halfEdgeInfo[d].valid)
{
(*errors)[d] = halfEdgeInfo[d].it->first ;
}
else
(*errors)[d] = -1 ;
}
}
} ;
/*****************************************************************************************************************
......@@ -222,205 +241,31 @@ public:
void updateAfterCollapse(Dart d2, Dart dd2) ;
void updateWithoutCollapse() { }
} ;
///*****************************************************************************************************************
// * HALF-EDGE LIGHTFIELD METRIC *
// *****************************************************************************************************************/
//template <typename PFP>
//class HalfEdgeSelector_Lightfield : public EdgeSelector<PFP>
//{
//public:
// typedef typename PFP::MAP MAP ;
// typedef typename PFP::VEC3 VEC3 ;
// typedef typename PFP::REAL REAL ;
//
//private:
// typedef struct
// {
// typename std::multimap<float,Dart>::iterator it ;
// bool valid ;
// static std::string CGoGNnameOfType() { return "LightfieldHalfEdgeInfo" ; }
// } QEMhalfEdgeInfo ;
// typedef NoMathIOAttribute<QEMhalfEdgeInfo> HalfEdgeInfo ;
//
// DartAttribute<HalfEdgeInfo> halfEdgeInfo ;
//
// VertexAttribute<VEC3> m_pos, m_frameT, m_frameB, m_frameN ;
// //VertexAttribute<VEC3> *m_HF ;
// int m_approxindex_pos, m_attrindex_pos ;
// int m_approxindex_FN, m_attrindex_FN ;
//
// VertexAttribute<Utils::Quadric<REAL> > m_quadricGeom ;
// VertexAttribute<Utils::QuadricHF<REAL> > m_quadricHF ;
//
// std::multimap<float,Dart> halfEdges ;
// typename std::multimap<float,Dart>::iterator cur ;
//
// std::vector<Approximator<PFP, typename PFP::VEC3>* > m_approx ;
//
// void initHalfEdgeInfo(Dart d) ;
// void updateHalfEdgeInfo(Dart d, bool recompute) ;
// void computeHalfEdgeInfo(Dart d, HalfEdgeInfo& einfo) ;
// void recomputeQuadric(const Dart d, const bool recomputeNeighbors = false) ;
//
//public:
// HalfEdgeSelector_Lightfield(MAP& m, VertexAttribute<typename PFP::VEC3>& pos, std::vector<ApproximatorGen<PFP>*>& approx, const FunctorSelect& select = allDarts) :
// EdgeSelector<PFP>(m, pos, approx, select),
//// m_positionApproximator(NULL),
//// m_frameApproximator(NULL),
//// m_hfcoefsApproximator(NULL),
//// m_pos(NULL),
//// m_frameB(NULL),
//// m_frameN(NULL),
//// m_frameT(NULL),
// m_approxindex_pos(-1),
// m_attrindex_pos(-1),
// m_approxindex_FN(-1),
// m_attrindex_FN(-1)
// {
// halfEdgeInfo = m.template addAttribute<HalfEdgeInfo, DART>("halfEdgeInfo") ;
// m_quadricGeom = m.template addAttribute<Utils::Quadric<REAL>, VERTEX>("QEMquadric") ;
// m_quadricHF = m.template addAttribute<Utils::QuadricHF<REAL>, VERTEX>("HFquadric") ;
// }
// ~HalfEdgeSelector_Lightfield()
// {
// this->m_map.removeAttribute(halfEdgeInfo) ;
// this->m_map.removeAttribute(m_quadricGeom) ;
// this->m_map.removeAttribute(m_quadricHF) ;
// }
// SelectorType getType() { return S_hLightfield ; }
// bool init() ;
// bool nextEdge(Dart& d) ;
// void updateBeforeCollapse(Dart d) ;
// void updateAfterCollapse(Dart d2, Dart dd2) ;
//} ;
/*template <typename PFP>
class HalfEdgeSelector_Lightfield_deprecated : public EdgeSelector<PFP>
{
public:
typedef typename PFP::MAP MAP ;
typedef typename PFP::VEC3 VEC3 ;
typedef typename PFP::REAL REAL ;
typedef Geom::Matrix<3,3,REAL> MATRIX33 ;
typedef Geom::Matrix<3,6,REAL> MATRIX36 ;
private:
typedef struct
void getEdgeErrors(EdgeAttribute<typename PFP::REAL> *errors)
{
typename std::multimap<float,Dart>::iterator it ;
bool valid ;
static std::string CGoGNnameOfType() { return "LightfieldHalfEdgeInfo_deprecated" ; }
} LightfieldHalfEdgeInfo ;
typedef NoMathIOAttribute<LightfieldHalfEdgeInfo> HalfEdgeInfo ;
VertexAttribute<MATRIX33> m_frame ;
DartAttribute<HalfEdgeInfo> halfEdgeInfo ;
VertexAttribute<Utils::Quadric<REAL> > quadric ;
EdgeAttribute<Utils::QuadricRGBfunctions<REAL> > quadricRGBfunctions ;
std::multimap<float,Dart> halfEdges ;
typename std::multimap<float,Dart>::iterator cur ;
Approximator<PFP, VEC3>* m_positionApproximator ;
Approximator<PFP, MATRIX33 >* m_frameApproximator ;
Approximator<PFP, MATRIX36 >* m_RGBfunctionsApproximator ;
void initHalfEdgeInfo(Dart d) ;
void updateHalfEdgeInfo(Dart d, bool recompute) ;
void computeHalfEdgeInfo(Dart d, HalfEdgeInfo& einfo) ;
void recomputeQuadric(const Dart d, const bool recomputeNeighbors) ;
public:
HalfEdgeSelector_Lightfield_deprecated(MAP& m, VertexAttribute<typename PFP::VEC3>& pos, std::vector<ApproximatorGen<PFP>*>& approx, const FunctorSelect& select = allDarts) :
EdgeSelector<PFP>(m, pos, approx, select)
{
m_frame = m.template getAttribute<MATRIX33, VERTEX>("frame") ;
halfEdgeInfo = m.template addAttribute<HalfEdgeInfo, DART>("halfEdgeInfo") ;
quadric = m.template addAttribute<Utils::Quadric<REAL>, VERTEX>("QEMquadric") ;
quadricRGBfunctions = m.template addAttribute<Utils::QuadricRGBfunctions<REAL>, EDGE>("quadricRGBfunctions") ;
}
~HalfEdgeSelector_Lightfield_deprecated()
{
this->m_map.removeAttribute(quadric) ;
this->m_map.removeAttribute(quadricRGBfunctions) ;
this->m_map.removeAttribute(halfEdgeInfo) ;
assert(errors != NULL || !"EdgeSelector::setColorMap requires non null vertexattribute argument") ;
if (!errors->isValid())
std::cerr << "EdgeSelector::setColorMap requires valid edgeattribute argument" << std::endl ;
assert(halfEdgeInfo.isValid()) ;
TraversorE<typename PFP::MAP> travE(this->m_map) ;
for(Dart d = travE.begin() ; d != travE.end() ; d = travE.next())
{
(*errors)[d] = -1 ;
if (halfEdgeInfo[d].valid)
{
(*errors)[d] = halfEdgeInfo[d].it->first ;
}
Dart dd = this->m_map.phi2(d) ;
if (halfEdgeInfo[dd].valid && halfEdgeInfo[d].it->first < (*errors)[d])
{
(*errors)[d] = halfEdgeInfo[dd].it->first ;
}
}
}
SelectorType getType() { return S_hLightfield_deprecated ; }
bool init() ;
bool nextEdge(Dart& d) ;
void updateBeforeCollapse(Dart d) ;
void updateAfterCollapse(Dart d2, Dart dd2) ;
} ;
/ *
template <typename PFP>
class EdgeSelector_Lightfield : public EdgeSelector<PFP>
{
public:
typedef typename PFP::MAP MAP ;
typedef typename PFP::VEC3 VEC3 ;
typedef typename PFP::REAL REAL ;
typedef Geom::Matrix<3,3,REAL> MATRIX33 ;
typedef MATRIX33 FRAME ;
typedef Geom::Matrix<3,6,REAL> MATRIX36 ;
typedef MATRIX36 RGBFUNCTIONS ;
private:
typedef struct
{
typename std::multimap<float,Dart>::iterator it ;
bool valid ;
static std::string CGoGNnameOfType() { return "LightfieldEdgeInfo" ; }
} LightfieldEdgeInfo ;
typedef NoMathIOAttribute<LightfieldEdgeInfo> EdgeInfo ;
AttributeHandler<FRAME > m_frame ;
AttributeHandler<EdgeInfo, EDGE> edgeInfo ;
AttributeHandler<Utils::Quadric<REAL>, VERTEX> quadric ;
AttributeHandler<Utils::QuadricRGBfunctions<REAL>, EDGE> quadricRGBfunctions ;
Utils::Quadric<REAL> tmpQ ;
std::multimap<float,Dart> edges ;
typename std::multimap<float,Dart>::iterator cur ;
Approximator<PFP, VEC3>* m_positionApproximator ;
Approximator<PFP, FRAME >* m_frameApproximator ;
Approximator<PFP, RGBFUNCTIONS >* m_RGBfunctionsApproximator ;
void initEdgeInfo(Dart d) ;
void updateEdgeInfo(Dart d, bool recompute) ;
void computeEdgeInfo(Dart d, EdgeInfo& einfo) ;
public:
EdgeSelector_Lightfield(MAP& m, VertexAttribute<typename PFP::VEC3>& pos, std::vector<ApproximatorGen<PFP>*>& approx, const FunctorSelect& select = allDarts) :
EdgeSelector<PFP>(m, pos, approx, select)
{
m_frame = m.template getAttribute<FRAME, VERTEX>("frame") ;
edgeInfo = m.template addAttribute<EdgeInfo, EDGE>("edgeInfo") ;
quadric = m.template addAttribute<Utils::Quadric<REAL>, VERTEX>("QEMquadric") ;
quadricRGBfunctions = m.template addAttribute<Utils::QuadricRGBfunctions<REAL>, EDGE>("quadricRGBfunctions") ;
}
~EdgeSelector_Lightfield()
{
this->m_map.removeAttribute(quadric) ;
this->m_map.removeAttribute(quadricRGBfunctions) ;
this->m_map.removeAttribute(edgeInfo) ;
}
SelectorType getType() { return S_Lightfield ; }
bool init() ;
bool nextEdge(Dart& d) ;
void updateBeforeCollapse(Dart d) ;
void updateAfterCollapse(Dart d2, Dart dd2) ;
} ;*/
} // namespace Decimation
} // namespace Algo
......
......@@ -84,16 +84,7 @@ public:
virtual void getEdgeErrors(EdgeAttribute<typename PFP::REAL> *errors)
{
// assert(colors != NULL || !"EdgeSelector::setColorMap requires non null vertexattribute argument") ;
// if (!colors->isValid())
// std::cerr << "EdgeSelector::setColorMap requires valid vertexattribute argument" << std::endl ;
//
// TraversorV<typename PFP::MAP> travV(map);
// for(Dart d = travV.begin() ; d != travV.end() ; d = travV.next())
// {
// REAL scaled = scale_to_0_1(error,edges.begin()->first,edges.rbegin()->first) ;
// (*colors)[d] = color_map_blue_green_red(scaled) ;
// }
std::cout << "WARNING:: getEdgeErrors was not overridden" << std::endl ;
}
} ;
......
......@@ -29,6 +29,9 @@
* \file tensor.h
*/
#define CONST_VAL -5212368.54127 // random value
namespace CGoGN
{
......@@ -192,6 +195,15 @@ class Tensor
*/
static bool incremIndex(std::vector<unsigned int>& p) ;
/*!
* \brief method to complete a symmetric tensor that was
* only filled in its first half (defined by an index that
* is order ascendantly)
*
* \param T the tensor to fill
*/
void completeSymmetricTensor() ;
/**********************************************/
/* STREAM OPERATORS */
/**********************************************/
......
......@@ -134,6 +134,21 @@ Tensor<SIZE, REAL>::getIndex(std::vector<unsigned int> p) const
return res ;
}
template <unsigned int SIZE, typename REAL>
void
Tensor<SIZE, REAL>::completeSymmetricTensor()
{
std::vector<unsigned int> p ;
p.resize(order(), 0) ;
do
{
std::vector<unsigned int> sorted_p = p ;
std::sort(sorted_p.begin(), sorted_p.begin() + (*this).order()) ;
(*this)(p) = (*this)(sorted_p) ;
} while (incremIndex(p)) ;
}
template <unsigned int SIZE, typename REAL>
const unsigned int&
Tensor<SIZE, REAL>::order() const
......
......@@ -256,7 +256,7 @@ void ColourConverter<REAL>::convertHSVtoRGB()
const REAL& s = (*HSV)[1] ;
const REAL& v = (*HSV)[2] ;
const unsigned int Hi = (unsigned int)(std::floor(H / 60)) % 6 ;
const unsigned int Hi = (unsigned int)(floor(H / 60)) % 6 ;
const REAL f = (H / 60) - Hi ;
const REAL l = v * (1 - s) ;
const REAL m = v * (1 - f * s) ;
......
......@@ -40,8 +40,6 @@
// Eigen includes
#include <Eigen/Dense>
#define CONST_VAL -5212368.54127 // random value
/*! \namespace CGoGN
* \brief namespace for all elements composing the CGoGN library
*/
......@@ -563,12 +561,22 @@ public:
static std::vector<VEC3> coefsFromTensors(Geom::Tensor3d* T) ;
/*!
* \brief method to complete a symmetric tensor that was
* only filled in its first half
* \brief method to complete a symmetric matrix that was
* only filled in its first half (line >= column)
*
* \param T the tensor to fill
* \param M the matrix to fill
*/
static void fillTensor(Geom::Tensor3d& T) ;
static void fillSymmetricMatrix(Eigen::MatrixXd& M) ;
/*!
* \brief method to rotate a tensor representing a polynomial light field
*
* \param T the tensor representing a polynomial light field
* \param R the 3x3 matrix representing a rotation in (u,v,1)-space
*
* \return a new rotated tensor representing a polynomial light field.
*/
static Geom::Tensor3d rotate(const Geom::Tensor3d& T, const Geom::Matrix33d& R) ;
private:
// Double computation is crucial for stability
......@@ -595,7 +603,7 @@ private:
*/
bool optimize(std::vector<VEC3>& coefs) const ;
Geom::Tensor3d rotate(const Geom::Tensor3d& T, const Geom::Matrix33d& R) ;
// Geom::Tensor3d rotate(const Geom::Tensor3d& T, const Geom::Matrix33d& R) ;
/*!
* \brief method to build a rotate matrix (rotation in tangent plane)
......@@ -639,6 +647,9 @@ private:
* \return the integral of product of monomes
*/
Eigen::MatrixXd buildIntegralMatrix_C(const REAL& alpha, unsigned int size) ;
Eigen::MatrixXd buildLowerLeftIntegralMatrix_A(const REAL& alpha, unsigned int size) ;
Eigen::MatrixXd buildLowerLeftIntegralMatrix_C(const REAL& alpha, unsigned int size) ;
} ;
} // Utils
......
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment