Commit e73d3657 authored by untereiner's avatar untereiner

file management 3

parent 72a083a4
......@@ -29,7 +29,7 @@
#include "Topology/generic/traversorCell.h"
#include "Topology/generic/traversor2.h"
#include "Algo/Multiresolution/map2MR/filters_Primal.h"
#include "Algo/Multiresolution/filter.h"
namespace CGoGN
{
......@@ -59,8 +59,8 @@ protected:
MAP& m_map;
bool shareVertexEmbeddings ;
std::vector<Algo::MR::Filter*> synthesisFilters ;
std::vector<Algo::MR::Filter*> analysisFilters ;
std::vector<Filter*> synthesisFilters ;
std::vector<Filter*> analysisFilters ;
public:
Map2MR(MAP& map) ;
......@@ -70,8 +70,8 @@ public:
void addNewLevelSqrt3(bool embedNewVertices = true);
void addSynthesisFilter(Algo::MR::Filter* f) { synthesisFilters.push_back(f) ; }
void addAnalysisFilter(Algo::MR::Filter* f) { analysisFilters.push_back(f) ; }
void addSynthesisFilter(Filter* f) { synthesisFilters.push_back(f) ; }
void addAnalysisFilter(Filter* f) { analysisFilters.push_back(f) ; }
void clearSynthesisFilters() { synthesisFilters.clear() ; }
void clearAnalysisFilters() { analysisFilters.clear() ; }
......
This diff is collapsed.
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg *
* *
* 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; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: http://cgogn.unistra.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#ifndef __3MR_LERP_FILTER__
#define __3MR_LERP_FILTER__
#include <cmath>
#include "Algo/Geometry/centroid.h"
#include "Algo/Modelisation/tetrahedralization.h"
#include "Algo/Multiresolution/filter.h"
namespace CGoGN
{
namespace Algo
{
namespace MR
{
namespace Primal
{
namespace Filters
{
/*********************************************************************************
* SYNTHESIS FILTERS
*********************************************************************************/
/* Linear Interpolation
*********************************************************************************/
template <typename PFP>
class LerpEdgeSynthesisFilter : public Filter
{
protected:
typename PFP::MAP& m_map ;
VertexAttribute<typename PFP::VEC3>& m_position ;
public:
LerpEdgeSynthesisFilter(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
{}
void operator() ()
{
TraversorE<typename PFP::MAP> trav(m_map) ;
for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
{
typename PFP::VEC3 p = (m_position[d] + m_position[m_map.phi2(d)]) * typename PFP::REAL(0.5);
m_map.incCurrentLevel() ;
Dart midV = m_map.phi2(d) ;
m_position[midV] = p ;
m_map.decCurrentLevel() ;
}
}
} ;
template <typename PFP>
class LerpFaceSynthesisFilter : public Filter
{
protected:
typename PFP::MAP& m_map ;
VertexAttribute<typename PFP::VEC3>& m_position ;
public:
LerpFaceSynthesisFilter(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
{}
void operator() ()
{
TraversorF<typename PFP::MAP> trav(m_map) ;
for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
{
typename PFP::VEC3 p = Algo::Geometry::faceCentroid<PFP>(m_map, d, m_position);
m_map.incCurrentLevel() ;
if(m_map.faceDegree(d) != 3)
{
Dart midF = m_map.phi2(m_map.phi1(d));
m_position[midF] = p ;
}
m_map.decCurrentLevel() ;
}
}
} ;
template <typename PFP>
class LerpVolumeSynthesisFilter : public Filter
{
protected:
typename PFP::MAP& m_map ;
VertexAttribute<typename PFP::VEC3>& m_position ;
public:
LerpVolumeSynthesisFilter(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
{}
void operator() ()
{
TraversorW<typename PFP::MAP> trav(m_map) ;
for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
{
typename PFP::VEC3 p = Algo::Geometry::volumeCentroid<PFP>(m_map, d, m_position);
m_map.incCurrentLevel() ;
if(!Algo::Modelisation::Tetrahedralization::isTetrahedron<PFP>(m_map,d))
{
Dart midV = m_map.phi_1(m_map.phi2(m_map.phi1(d)));
m_position[midV] = p ;
}
m_map.decCurrentLevel() ;
}
}
} ;
} // namespace Filters
} // namespace Primal
} // namespace MR
} // namespace Algo
} // namespace CGoGN
#endif /* __3MR_FILTERS_PRIMAL__ */
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg *
* *
* 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; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: http://cgogn.unistra.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#ifndef __3MR_MCCRACKENJOY_FILTER__
#define __3MR_MCCRACKENJOY_FILTER__
#include <cmath>
#include "Algo/Geometry/centroid.h"
#include "Algo/Modelisation/tetrahedralization.h"
namespace CGoGN
{
namespace Algo
{
namespace MR
{
namespace Primal
{
namespace Filters
{
/* Catmull-clark on Boundary Vertices and MJ96 on Insides Vertices
*********************************************************************************/
template <typename PFP>
class MJ96VertexSubdivision : public Filter
{
protected:
typename PFP::MAP& m_map ;
VertexAttribute<typename PFP::VEC3>& m_position ;
public:
MJ96VertexSubdivision(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
{}
void operator() ()
{
TraversorV<typename PFP::MAP> trav(m_map) ;
for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
{
if(m_map.isBoundaryVertex(d))
{
Dart db = m_map.findBoundaryFaceOfVertex(d);
typename PFP::VEC3 np1(0) ;
typename PFP::VEC3 np2(0) ;
unsigned int degree1 = 0 ;
unsigned int degree2 = 0 ;
Dart it = db ;
do
{
++degree1 ;
Dart dd = m_map.phi1(it) ;
np1 += m_position[dd] ;
Dart end = m_map.phi_1(it) ;
dd = m_map.phi1(dd) ;
do
{
++degree2 ;
np2 += m_position[dd] ;
dd = m_map.phi1(dd) ;
} while(dd != end) ;
it = m_map.phi2(m_map.phi_1(it)) ;
} while(it != db) ;
float beta = 3.0 / (2.0 * degree1) ;
float gamma = 1.0 / (4.0 * degree2) ;
np1 *= beta / degree1 ;
np2 *= gamma / degree2 ;
typename PFP::VEC3 vp = m_position[db] ;
vp *= 1.0 - beta - gamma ;
m_map.incCurrentLevel() ;
m_position[d] = np1 + np2 + vp ;
m_map.decCurrentLevel() ;
}
else
{
typename PFP::VEC3 P = m_position[d];
//vertex points
typename PFP::VEC3 Cavg = typename PFP::VEC3(0);
unsigned int degree = 0;
Traversor3VW<typename PFP::MAP> travVW(m_map, d);
for(Dart dit = travVW.begin() ; dit != travVW.end() ; dit = travVW.next())
{
Cavg += Algo::Geometry::volumeCentroid<PFP>(m_map, dit, m_position);
++degree;
}
Cavg /= degree;
typename PFP::VEC3 Aavg = typename PFP::VEC3(0);
degree = 0;
Traversor3VF<typename PFP::MAP> travVF(m_map, d);
for(Dart dit = travVF.begin() ; dit != travVF.end() ; dit = travVF.next())
{
Aavg += Algo::Geometry::faceCentroid<PFP>(m_map, dit, m_position);
++degree;
}
Aavg /= degree;
typename PFP::VEC3 Mavg = typename PFP::VEC3(0);
degree = 0;
Traversor3VE<typename PFP::MAP> travVE(m_map, d);
for(Dart dit = travVE.begin() ; dit != travVE.end() ; dit = travVE.next())
{
Dart d2 = m_map.phi2(dit);
Aavg += (m_position[dit] + m_position[d2]) * typename PFP::REAL(0.5);
++degree;
}
Aavg /= degree;
typename PFP::VEC3 vp = Cavg + Aavg * 3 + Mavg * 3 + P;
vp /= 8;
m_map.incCurrentLevel() ;
m_position[d] = P;//vp;
m_map.decCurrentLevel() ;
}
}
}
};
template <typename PFP>
class MJ96EdgeSubdivision : public Filter
{
protected:
typename PFP::MAP& m_map ;
VertexAttribute<typename PFP::VEC3>& m_position ;
public:
MJ96EdgeSubdivision(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
{}
void operator() ()
{
TraversorE<typename PFP::MAP> trav(m_map) ;
for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
{
if(m_map.isBoundaryEdge(d))
{
Dart db = m_map.findBoundaryFaceOfEdge(d);
Dart d1 = m_map.phi2(db) ;
Dart d2 = m_map.phi2(d1) ;
Dart d3 = m_map.phi_1(d1) ;
Dart d4 = m_map.phi_1(d2) ;
Dart d5 = m_map.phi1(m_map.phi1(d1)) ;
Dart d6 = m_map.phi1(m_map.phi1(d2)) ;
typename PFP::VEC3 p1 = m_position[d1] ;
typename PFP::VEC3 p2 = m_position[d2] ;
typename PFP::VEC3 p3 = m_position[d3] ;
typename PFP::VEC3 p4 = m_position[d4] ;
typename PFP::VEC3 p5 = m_position[d5] ;
typename PFP::VEC3 p6 = m_position[d6] ;
p1 *= 3.0 / 8.0 ;
p2 *= 3.0 / 8.0 ;
p3 *= 1.0 / 16.0 ;
p4 *= 1.0 / 16.0 ;
p5 *= 1.0 / 16.0 ;
p6 *= 1.0 / 16.0 ;
m_map.incCurrentLevel() ;
Dart midV = m_map.phi2(d);
m_position[midV] = p1 + p2 + p3 + p4 + p5 + p6 ;
m_map.decCurrentLevel() ;
}
else
{
//edge points
typename PFP::VEC3 Cavg = typename PFP::VEC3(0);
unsigned int degree = 0;
Traversor3EW<typename PFP::MAP> travEW(m_map, d);
for(Dart dit = travEW.begin() ; dit != travEW.end() ; dit = travEW.next())
{
Cavg += Algo::Geometry::volumeCentroid<PFP>(m_map, dit, m_position);
++degree;
}
Cavg /= degree;
typename PFP::VEC3 Aavg = typename PFP::VEC3(0);
degree = 0;
Traversor3EF<typename PFP::MAP> travEF(m_map, d);
for(Dart dit = travEF.begin() ; dit != travEF.end() ; dit = travEF.next())
{
Aavg += Algo::Geometry::faceCentroid<PFP>(m_map, dit, m_position);
++degree;
}
Aavg /= degree;
Dart d2 = m_map.phi2(d);
typename PFP::VEC3 M = (m_position[d] + m_position[d2]) * typename PFP::REAL(0.5);
typename PFP::VEC3 ep = Cavg + Aavg * 2 + M * (degree - 3);
ep /= degree;
m_map.incCurrentLevel() ;
Dart midV = m_map.phi2(d);
m_position[midV] = ep;
m_map.decCurrentLevel() ;
}
}
}
};
template <typename PFP>
class MJ96FaceSubdivision : public Filter
{
protected:
typename PFP::MAP& m_map ;
VertexAttribute<typename PFP::VEC3>& m_position ;
public:
MJ96FaceSubdivision(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
{}
void operator() ()
{
TraversorF<typename PFP::MAP> trav(m_map) ;
for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
{
if(m_map.isBoundaryFace(d))
{
Dart db = m_map.phi3(d);
typename PFP::VEC3 p(0) ;
unsigned int degree = 0 ;
Traversor2FV<typename PFP::MAP> trav(m_map, db) ;
for(Dart it = trav.begin(); it != trav.end(); it = trav.next())
{
++degree ;
p += m_position[it] ;
}
p /= degree ;
m_map.incCurrentLevel() ;
Dart df = m_map.phi1(m_map.phi1(d)) ;
m_position[df] = p ;
m_map.decCurrentLevel() ;
}
else
{
//face points
typename PFP::VEC3 C0 = Algo::Geometry::volumeCentroid<PFP>(m_map, d, m_position);
typename PFP::VEC3 C1 = Algo::Geometry::volumeCentroid<PFP>(m_map, m_map.phi3(d), m_position);
typename PFP::VEC3 A = Algo::Geometry::faceCentroid<PFP>(m_map, m_map.phi3(d), m_position);
typename PFP::VEC3 fp = C0 + A * 2 + C1;
fp /= 4;
m_map.incCurrentLevel() ;
Dart df = m_map.phi1(m_map.phi1(d)) ;
m_position[df] = fp;
m_map.decCurrentLevel() ;
}
}
}
};
template <typename PFP>
class MJ96VolumeSubdivision : public Filter
{
protected:
typename PFP::MAP& m_map ;
VertexAttribute<typename PFP::VEC3>& m_position ;
public:
MJ96VolumeSubdivision(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
{}
void operator() ()
{
TraversorW<typename PFP::MAP> trav(m_map) ;
for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
{
//cell points : these points are the average of the
//vertices of the lattice that bound the cell
typename PFP::VEC3 p = Algo::Geometry::volumeCentroid<PFP>(m_map, d, m_position);
m_map.incCurrentLevel() ;
if(!Algo::Modelisation::Tetrahedralization::isTetrahedron<PFP>(m_map,d))
{
Dart midV = m_map.phi_1(m_map.phi2(m_map.phi1(d)));
m_position[midV] = p ;
}
m_map.decCurrentLevel() ;
}
}
};
} // namespace Filters
} // namespace Primal
} // namespace MR
} // namespace Algo
} // namespace CGoGN
#endif /* __3MR_FILTERS_PRIMAL__ */
......@@ -29,7 +29,7 @@
#include "Topology/generic/traversorCell.h"
#include "Topology/generic/traversor3.h"
#include "Algo/Multiresolution/map3MR/filters_Primal.h"
#include "Algo/Multiresolution/filter.h"
#include "Algo/Modelisation/tetrahedralization.h"
namespace CGoGN
......
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