Création d'un compte pour un collaborateur extérieur au laboratoire depuis l'intranet ICube : https://intranet.icube.unistra.fr/fr/labs/member/profile

Commit 5feedc27 authored by Sylvain Thery's avatar Sylvain Thery
Browse files

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

Conflicts:
	include/Algo/Selection/collector.h
parents 63ca7b83 21bb3f51
#ifndef __VORONOI_DIAGRAMS_H__
#define __VORONOI_DIAGRAMS_H__
#include <vector>
#include <map>
#include "Topology/generic/traversor2.h"
namespace CGoGN
{
namespace Algo
{
namespace Geometry
{
template <typename PFP>
class VoronoiDiagram {
private :
typedef typename PFP::REAL REAL;
typedef typename PFP::VEC3 VEC3;
typedef struct
{
typename std::multimap<float,Dart>::iterator it ;
bool valid ;
unsigned int region;
static std::string CGoGNnameOfType() { return "VoronoiVertexInfo" ; }
} VoronoiVertexInfo ;
typedef NoMathIOAttribute<VoronoiVertexInfo> VertexInfo ;
typename PFP::MAP& map;
const EdgeAttribute<REAL>& edgeCost; // weights on the graph edges
// const VertexAttribute<VEC3>& position; // positions
VertexAttribute<unsigned int>& regions; // region labels
std::vector<Dart> border;
std::vector<Dart> seeds;
VertexAttribute<VertexInfo> vertexInfo;
std::multimap<float,Dart> front ;
CellMarkerStore<VERTEX> vmReached;
public :
VoronoiDiagram (typename PFP::MAP& m, const EdgeAttribute<REAL>& c, VertexAttribute<unsigned int>& r);
~VoronoiDiagram ();
const std::vector<Dart>& getSeeds (){return seeds;}
void setSeeds (const std::vector<Dart>&);
void setRandomSeeds (unsigned int nbseeds);
const std::vector<Dart>& getBorder (){return border;}
void setCost (const EdgeAttribute<REAL>& c);
void computeDiagram ();
private :
void clear ();
void initFrontWithSeeds();
};
}// end namespace Geometry
}// end namespace Algo
}// end namespace CGoGN
#include "voronoiDiagrams.hpp"
#endif
namespace CGoGN
{
namespace Algo
{
namespace Geometry
{
template <typename PFP>
VoronoiDiagram<PFP>::VoronoiDiagram (typename PFP::MAP& m, const EdgeAttribute<REAL>& p, VertexAttribute<unsigned int>& r) : map(m), edgeCost (p), regions (r), vmReached(m)
{
vertexInfo = map.template addAttribute<VertexInfo, VERTEX>("vertexInfo");
}
template <typename PFP>
VoronoiDiagram<PFP>::~VoronoiDiagram ()
{
map.removeAttribute(vertexInfo);
}
template <typename PFP>
void VoronoiDiagram<PFP>::clear ()
{
border.clear();
regions.setAllValues(0);
border.clear();
seeds.clear();
front.clear();
vmReached.unmarkAll();
}
template <typename PFP>
void VoronoiDiagram<PFP>::setSeeds (const std::vector<Dart>& s)
{
clear();
seeds = s;
}
template <typename PFP>
void VoronoiDiagram<PFP>::setRandomSeeds (unsigned int nseeds)
{
clear();
srand ( time(NULL) );
unsigned int n = nseeds;
while (n > 0)
{ // TODO : correct this random init which assumes contiguous Dart table
Dart d = rand() % map.getNbDarts() ;
if (! vmReached.isMarked(d))
{
vmReached.mark(d);
seeds.push_back(d);
n--;
}
}
}
template <typename PFP>
void VoronoiDiagram<PFP>::initFrontWithSeeds ()
{
vmReached.unmarkAll();
for (unsigned int i = 0; i < seeds.size(); i++)
{
Dart d = seeds[i];
vmReached.mark(d);
vertexInfo[d].it = front.insert(std::pair<float,Dart>(0.0, d));
vertexInfo[d].valid = true;
vertexInfo[d].region = i;
}
}
template <typename PFP>
void VoronoiDiagram<PFP>::setCost (const EdgeAttribute<typename PFP::REAL>& c){
edgeCost = c;
}
template <typename PFP>
void VoronoiDiagram<PFP>::computeDiagram ()
{
initFrontWithSeeds();
while ( !front.empty() )
{
Dart e = front.begin()->second;
float d = front.begin()->first;
front.erase(vertexInfo[e].it);
vertexInfo[e].valid=false;
regions[e] = vertexInfo[e].region;
Traversor2VVaE<typename PFP::MAP> tv (map, e);
for (Dart f = tv.begin(); f != tv.end(); f=tv.next())
{
VertexInfo& vi (vertexInfo[f]);
if (vmReached.isMarked(f))
{
if (vi.valid) // probably useless (because of distance test) but faster
{
// float dist = d + Algo::Geometry::edgeLength<PFP>(map,f,position);
float dist = d + edgeCost[f];
if (dist < vi.it->first)
{
front.erase(vi.it);
vi.it = front.insert(std::pair<float,Dart>(dist, f));
vi.region = regions[e];
}
}
else
{
if ( regions[f] != regions[e] )
border.push_back(f);
}
}
else
{
// vi.it = front.insert(std::pair<float,Dart>(d + Algo::Geometry::edgeLength<PFP>(map,f,position), f));
vi.it = front.insert(std::pair<float,Dart>(d + edgeCost[f], f));
vi.valid=true;
vi.region = regions[e];
vmReached.mark(f);
}
}
}
}
}// end namespace Geometry
}// end namespace Algo
}// end namespace CGoGN
......@@ -134,6 +134,7 @@ inline void Histogram::initData(const ATTR& attr)
m_max = m_min;
m_dataIdx.reserve(attr.nbElements());
m_dataIdx.clear();
for (unsigned int i = beg; i!= attr.end(); attr.next(i))
{
double val = attr[i];
......@@ -147,6 +148,7 @@ inline void Histogram::initData(const ATTR& attr)
m_hcolmap.setMin(m_min);
m_hcolmap.setMax(m_max);
m_sorted = false;
}
......
......@@ -151,8 +151,7 @@ public:
Collector<PFP>(m, thread),
position(p),
radius(r),
area(0),
m_thread(thread)
area(0)
{}
inline void setRadius(typename PFP::REAL r) { radius = r; }
inline typename PFP::REAL getRadius() const { return radius; }
......@@ -166,7 +165,7 @@ public:
};
/*********************************************************
* Collector Normal Angle
* Collector Normal Angle (Vertices)
*********************************************************/
/*
......@@ -178,28 +177,108 @@ template <typename PFP>
class Collector_NormalAngle : public Collector<PFP>
{
protected:
const VertexAttribute<typename PFP::VEC3>& position ;
const VertexAttribute<typename PFP::VEC3>& normal ;
typename PFP::REAL angleThreshold ;
public:
Collector_NormalAngle(
typename PFP::MAP& m,
const VertexAttribute<typename PFP::VEC3>& p,
const VertexAttribute<typename PFP::VEC3>& n,
typename PFP::REAL a,
unsigned int thread=0
) : Collector<PFP>(m,thread), position(p), normal(n), angleThreshold(a)
) : Collector<PFP>(m,thread), normal(n), angleThreshold(a)
{}
inline void setAngleThreshold(typename PFP::REAL a) { angleThreshold = a; }
inline typename PFP::REAL getAngleThreshold() const { return angleThreshold; }
inline const VertexAttribute<typename PFP::VEC3>& getPosition() const { return position ; }
inline const VertexAttribute<typename PFP::VEC3>& getNormal() const { return normal ; }
void collectAll(Dart d) ;
void collectBorder(Dart d) ;
};
/*********************************************************
* Collector Normal Angle (Triangles)
*********************************************************/
/*
* collect all primitives of the connected component containing "centerDart"
* the angle between the included triangles normal vectors and the central normal vector
* stays under a given threshold
*/
template <typename PFP>
class Collector_NormalAngle_Triangles : public Collector<PFP>
{
protected:
const FaceAttribute<typename PFP::VEC3>& normal ;
typename PFP::REAL angleThreshold ;
public:
Collector_NormalAngle_Triangles(
typename PFP::MAP& m,
const FaceAttribute<typename PFP::VEC3>& n,
typename PFP::REAL a,
unsigned int thread=0
) : Collector<PFP>(m,thread), normal(n), angleThreshold(a)
{}
inline void setAngleThreshold(typename PFP::REAL a) { angleThreshold = a; }
inline typename PFP::REAL getAngleThreshold() const { return angleThreshold; }
inline const VertexAttribute<typename PFP::VEC3>& getNormal() const { return normal ; }
void collectAll(Dart d) ;
void collectBorder(Dart d) ;
};
/*********************************************************
* Collector Dijkstra
*********************************************************/
/*
* collect all primitives of the connected component containing "centerDart"
* within a distance < maxDist (the shortest path follows edges)
*/
template <typename PFP>
class Collector_Dijkstra : public Collector<PFP>
{
protected:
const VertexAttribute<typename PFP::VEC3>& position;
typename PFP::REAL maxDist;
typedef struct
{
typename std::multimap<float,Dart>::iterator it ;
bool valid ;
static std::string CGoGNnameOfType() { return "DijkstraVertexInfo" ; }
} DijkstraVertexInfo ;
typedef NoMathIOAttribute<DijkstraVertexInfo> VertexInfo ;
VertexAttribute<VertexInfo> vertexInfo ;
std::multimap<float,Dart> front ;
public:
Collector_Dijkstra(typename PFP::MAP& m, const VertexAttribute<typename PFP::VEC3>& p, typename PFP::REAL d = 0, unsigned int thread=0) :
Collector<PFP>(m,thread),
position(p),
maxDist(d)
{
vertexInfo = m.template addAttribute<VertexInfo, VERTEX>("vertexInfo");
}
~Collector_Dijkstra(){
this->map.removeAttribute(vertexInfo);
}
inline void init (Dart d) {Collector<PFP>::init(d); front.clear();}
inline void setMaxDistance(typename PFP::REAL d) { maxDist = d; }
inline typename PFP::REAL getMaxDist() const { return maxDist; }
inline const VertexAttribute<typename PFP::VEC3>& getPosition() const { return position; }
void collectAll(Dart d);
void collectBorder(Dart d);
private :
inline float edgeLength (Dart d);
// inline Dart oppositeVertex (Dart d);
};
} // namespace Selection
} // namespace Algo
......
......@@ -24,6 +24,7 @@
#include "Topology/generic/traversor2.h"
#include "Algo/Geometry/intersection.h"
#include <queue>
namespace CGoGN
{
......@@ -149,9 +150,9 @@ void Collector_WithinSphere<PFP>::collectAll(Dart d)
this->insideFaces.reserve(32);
this->border.reserve(32);
CellMarkerStore<VERTEX> vm(this->map, m_thread); // mark the collected inside-vertices
CellMarkerStore<EDGE> em(this->map, m_thread); // mark the collected inside-edges + border-edges
CellMarkerStore<FACE> fm(this->map, m_thread); // mark the collected inside-faces + border-faces
CellMarkerStore<VERTEX> vm(this->map, this->m_thread); // mark the collected inside-vertices
CellMarkerStore<EDGE> em(this->map, this->m_thread); // mark the collected inside-edges + border-edges
CellMarkerStore<FACE> fm(this->map, this->m_thread); // mark the collected inside-faces + border-faces
this->insideVertices.push_back(this->centerDart);
vm.mark(this->centerDart);
......@@ -211,8 +212,8 @@ void Collector_WithinSphere<PFP>::collectBorder(Dart d)
this->border.reserve(128);
this->insideVertices.reserve(128);
CellMarkerStore<VERTEX> vm(this->map, m_thread); // mark the collected inside-vertices
CellMarkerStore<EDGE> em(this->map, m_thread); // mark the collected inside-edges + border-edges
CellMarkerStore<VERTEX> vm(this->map, this->m_thread); // mark the collected inside-vertices
CellMarkerStore<EDGE> em(this->map, this->m_thread); // mark the collected inside-edges + border-edges
this->insideVertices.push_back(this->centerDart);
vm.mark(this->centerDart);
......@@ -281,7 +282,7 @@ void Collector_WithinSphere<PFP>::computeArea()
}
/*********************************************************
* Collector Normal Angle
* Collector Normal Angle (Vertices)
*********************************************************/
template <typename PFP>
......@@ -295,9 +296,9 @@ void Collector_NormalAngle<PFP>::collectAll(Dart d)
this->insideFaces.reserve(32);
this->border.reserve(32);
CellMarkerStore<VERTEX> vm(this->map, m_thread); // mark the collected inside-vertices
CellMarkerStore<EDGE> em(this->map, m_thread); // mark the collected inside-edges + border-edges
CellMarkerStore<FACE> fm(this->map, m_thread); // mark the collected inside-faces + border-faces
CellMarkerStore<VERTEX> vm(this->map, this->m_thread); // mark the collected inside-vertices
CellMarkerStore<EDGE> em(this->map, this->m_thread); // mark the collected inside-edges + border-edges
CellMarkerStore<FACE> fm(this->map, this->m_thread); // mark the collected inside-faces + border-faces
this->insideVertices.push_back(this->centerDart);
vm.mark(this->centerDart);
......@@ -360,8 +361,8 @@ void Collector_NormalAngle<PFP>::collectBorder(Dart d)
this->border.reserve(128);
this->insideVertices.reserve(128);
CellMarkerStore<VERTEX> vm(this->map, m_thread); // mark the collected inside-vertices
CellMarkerStore<EDGE> em(this->map, m_thread); // mark the collected inside-edges + border-edges
CellMarkerStore<VERTEX> vm(this->map, this->m_thread); // mark the collected inside-vertices
CellMarkerStore<EDGE> em(this->map, this->m_thread); // mark the collected inside-edges + border-edges
this->insideVertices.push_back(this->centerDart);
vm.mark(this->centerDart);
......@@ -401,6 +402,332 @@ void Collector_NormalAngle<PFP>::collectBorder(Dart d)
this->insideVertices.clear();
}
/*********************************************************
* Collector Normal Angle (Triangles)
*********************************************************/
template <typename PFP>
void Collector_NormalAngle_Triangles<PFP>::collectAll(Dart d)
{
typedef typename PFP::VEC3 VEC3;
typedef typename PFP::REAL REAL;
this->init(d);
this->insideVertices.reserve(32);
this->insideEdges.reserve(32);
this->insideFaces.reserve(32);
this->border.reserve(32);
CellMarkerStore<FACE> fm(this->map, this->m_thread); // mark the collected inside-faces + front-faces
CellMarkerStore<FACE> fminside(this->map, this->m_thread); // mark the collected inside-faces
std::queue<Dart> front;
front.push(this->centerDart);
fm.mark(this->centerDart);
VEC3 centerNormal = this->normal[this->centerDart];
while ( !front.empty() ) // collect inside faces
{
Dart f = front.front();
front.pop();
REAL a = Geom::angle(centerNormal, this->normal[f]);
if (a < angleThreshold )
{ // collect this face and add adjacent faces to the front
this->insideFaces.push_back(f);
fminside.mark(f);
Traversor2FFaE<typename PFP::MAP> t (this->map, f) ;
for (Dart it = t.begin(); it != t.end(); it=t.next())
{
if (!fm.isMarked(it))
{
front.push(it);
fm.mark(it);
}
}
}
}
CellMarkerStore<VERTEX> vm(this->map, this->m_thread); // mark inside-vertices and border-vertices
CellMarkerStore<EDGE> em(this->map, this->m_thread); // mark inside-edges and border-edges
std::vector<Dart>::iterator f_it;
for (f_it = this->insideFaces.begin(); f_it != this->insideFaces.end(); f_it++)
{ // collect insideVertices, insideEdges, and border
Traversor2FE<typename PFP::MAP> te (this->map, *f_it) ;
for (Dart it = te.begin(); it != te.end(); it=te.next())
{ // collect insideEdges and border
if (!em.isMarked(it))
{
em.mark(it);
if (this->map.isBoundaryEdge(it))
this->border.push_back(it);
else if ( fminside.isMarked(it) && fminside.isMarked(this->map.phi2(it)) )
this->insideEdges.push_back(it);
else
this->border.push_back(it);
}
}
Traversor2FV<typename PFP::MAP> tv (this->map, *f_it) ;
for (Dart it = tv.begin(); it != tv.end(); it=tv.next())
{ // collect insideVertices
if (!vm.isMarked(it))
{
vm.mark(it);
this->insideVertices.push_back(it);
// if ( !this->map.isBoundaryVertex(it))
// {
// Traversor2VF<typename PFP::MAP> tf (this->map, it);
// Dart it2 = tf.begin();
// while ( (it2 != tf.end()) && fminside.isMarked(it2))
// it2=tf.next();
// if (it2 == tf.end())
// this->insideVertices.push_back(it);
// }
}
}
}
}
template <typename PFP>
void Collector_NormalAngle_Triangles<PFP>::collectBorder(Dart d)
{
typedef typename PFP::VEC3 VEC3;
typedef typename PFP::REAL REAL;
this->init(d);
this->insideFaces.reserve(32);
this->border.reserve(32);
CellMarkerStore<FACE> fm(this->map, this->m_thread); // mark the collected inside-faces + front-faces
CellMarkerStore<FACE> fminside(this->map, this->m_thread); // mark the collected inside-faces
std::queue<Dart> front;
front.push(this->centerDart);
fm.mark(this->centerDart);
VEC3 centerNormal = this->normal[this->centerDart];
while ( !front.empty() ) // collect inside faces
{
Dart f = front.front();
front.pop();
REAL a = Geom::angle(centerNormal, this->normal[f]);
if (a < angleThreshold )
{ // collect this face and add adjacent faces to the front
this->insideFaces.push_back(f);
fminside.mark(f);
Traversor2FFaE<typename PFP::MAP> t (this->map, f) ;
for (Dart it = t.begin(); it != t.end(); it=t.next())
{
if (!fm.isMarked(it))
{
front.push(it);
fm.mark(it);
}
}
}
}
CellMarkerStore<EDGE> em(this->map, this->m_thread); // mark inside-edges and border-edges
std::vector<Dart>::iterator f_it;
for (f_it = this->insideFaces.begin(); f_it != this->insideFaces.end(); f_it++)
{ // collect border (edges)
Traversor2FE<typename PFP::MAP> te (this->map, *f_it) ;
for (Dart it = te.begin(); it != te.end(); it=te.next())
{
if (!em.isMarked(it))
{
em.mark(it);
if (this->map.isBoundaryEdge(it))
this->border.push_back(it);
else if ( !fminside.isMarked(it) || !fminside.isMarked(this->map.phi2(it)) )
this->border.push_back(it);
}
}
}
this->insideFaces.clear();
}
/*********************************************************
* Collector Dijkstra
*********************************************************/
template <typename PFP>
void Collector_Dijkstra<PFP>::collectAll(Dart dinit)
{
init(dinit);
CellMarkerStore<VERTEX> vmReached (this->map, this->m_thread);
vertexInfo[this->centerDart].it = front.insert(std::pair<float,Dart>(0.0, this->centerDart));
vertexInfo[this->centerDart].valid = true;
vmReached.mark(this->centerDart);
while ( !front.empty() && front.begin()->first < this->maxDist)
{
Dart e = front.begin()->second;
float d = front.begin()->first;
front.erase(vertexInfo[e].it);
vertexInfo[e].valid=false;
this->insideVertices.push_back(e);
Traversor2VVaE<typename PFP::MAP> tv (this->map, e);
for (Dart f = tv.begin(); f != tv.end(); f=tv.next())
{
VertexInfo& vi (vertexInfo[f]);
if (vmReached.isMarked(f))
{
if (vi.valid) // probably useless (because of distance test) but faster
{
float dist = d + edgeLength(f);
if (dist < vi.it->first)
{
front.erase(vi.it);
vi.it = front.insert(std::pair<float,Dart>(dist, f));