296 lines
9.5 KiB
C++
296 lines
9.5 KiB
C++
/****************************************************************************
|
|
* VCGLib o o *
|
|
* Visual and Computer Graphics Library o o *
|
|
* _ O _ *
|
|
* Copyright(C) 2004 \/)\/ *
|
|
* Visual Computing Lab /\/| *
|
|
* ISTI - Italian National Research Council | *
|
|
* \ *
|
|
* All rights reserved. *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program 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 General Public License (http://www.gnu.org/licenses/gpl.txt) *
|
|
* for more details. *
|
|
* *
|
|
****************************************************************************/
|
|
/****************************************************************************
|
|
History
|
|
|
|
$Log: not supported by cvs2svn $
|
|
|
|
****************************************************************************/
|
|
|
|
#ifndef VCG_MT_H
|
|
#define VCG_MT_H
|
|
|
|
#include <vector>
|
|
#include <queue>
|
|
#include <map>
|
|
|
|
#include <vcg/space/sphere3.h>
|
|
#include <vcg/space/point3.h>
|
|
#include <wrap/gui/frustum.h>
|
|
|
|
namespace vcg {
|
|
|
|
/** \addtogroup mt */
|
|
/*@{*/
|
|
/**
|
|
The templated class for representing a mt structure.
|
|
The class is templated over the Cell class which MUST implement this functions:
|
|
float Error();
|
|
float Distance(Cell &c, Point3f &p);
|
|
see mt_file.h for an example.
|
|
*/
|
|
|
|
template <class C> class MT {
|
|
public:
|
|
typedef C Cell;
|
|
|
|
private:
|
|
|
|
class Frag:public std::vector<Cell *> {};
|
|
|
|
struct Node {
|
|
std::vector<Node *> in;
|
|
std::vector<Node *> out;
|
|
std::vector<Frag> frags;
|
|
float error;
|
|
bool visited;
|
|
};
|
|
|
|
std::vector<Node> nodes;
|
|
|
|
public:
|
|
|
|
/** Update class for defining the history.
|
|
Notice how the Update class holds pointers.
|
|
You are responsible of holding the Cell structure and rebuild the structure
|
|
if the pointers change.
|
|
*/
|
|
class Update {
|
|
public:
|
|
std::vector<Cell *> erased;
|
|
std::vector<Cell *> created;
|
|
};
|
|
|
|
///build mt strucure from a sequence of updates.
|
|
void Load(std::vector<Update> &updates) {
|
|
//The last update erases everything.
|
|
assert(updates[0].erased.size() == 0);
|
|
|
|
//maps cell -> node containing it
|
|
std::map<Cell *, unsigned int> cell_node;
|
|
nodes.resize(updates.size());
|
|
|
|
//building fragments and nodes.
|
|
unsigned int current_node = 0;
|
|
std::vector<Update>::iterator u;
|
|
for(u = updates.begin(); u != updates.end(); u++) {
|
|
|
|
Node &node = nodes[current_node];
|
|
node.error = 0;
|
|
|
|
//created cells belong to this node, we look also for max error.
|
|
for(unsigned int i = 0; i < (*u).created.size(); i++) {
|
|
Cell *cell = (*u).created[i];
|
|
if(cell->Error() > node.error)
|
|
node.error = cell->Error();
|
|
|
|
cell_node[cell] = current_node;
|
|
}
|
|
|
|
//Every erased cell already belonged to a node.
|
|
//we record for each node its cells.
|
|
std::map<unsigned int, std::vector<Cell *> > node_erased;
|
|
|
|
for(unsigned int i = 0; i < (*u).erased.size(); i++) {
|
|
Cell *cell = (*u).erased[i];
|
|
assert(cell_node.count(cell));
|
|
node_erased[cell_node[cell]].push_back(cell);
|
|
}
|
|
|
|
//for every node with erased cells we build a frag and put the corresponding cells in it.
|
|
std::map<unsigned int, std::vector<Cell *> >::iterator e;
|
|
for(e = node_erased.begin(); e != node_erased.end(); e++) {
|
|
//Build a new Frag.
|
|
Frag fr;
|
|
float max_err = -1;
|
|
|
|
//Fill it with erased cells.
|
|
std::vector<Cell *> &cells = (*e).second;
|
|
std::vector<Cell *>::iterator k;
|
|
for(k = cells.begin(); k != cells.end(); k++) {
|
|
Cell *cell = (*k);
|
|
fr.push_back(cell);
|
|
if(cell->Error() > max_err)
|
|
max_err = cell->Error();
|
|
}
|
|
|
|
//Add the new Frag to the node.
|
|
unsigned int floor_node = (*e).first;
|
|
Node &oldnode = nodes[floor_node];
|
|
oldnode.frags.push_back(fr);
|
|
if(node.error < max_err)
|
|
node.error = max_err;
|
|
|
|
//Update in and out of the nodes.
|
|
node.in.push_back(&oldnode);
|
|
oldnode.out.push_back(&node);
|
|
}
|
|
current_node++;
|
|
}
|
|
}
|
|
void Clear() {
|
|
nodes.clear();
|
|
}
|
|
|
|
///error based extraction
|
|
template <class CONT> void Extract(CONT &selected, float error) {
|
|
std::vector<Node>::iterator n;
|
|
for(n = nodes.begin(); n != nodes.end(); n++)
|
|
(*n).visited = false;
|
|
|
|
std::queue<Node *> qnodo;
|
|
qnodo.push(&nodes[0]);
|
|
nodes[0].visited = true;
|
|
|
|
for( ; !qnodo.empty(); qnodo.pop()) {
|
|
Node &node = *qnodo.front();
|
|
|
|
std::vector<Frag>::iterator fragment;
|
|
std::vector<Node *>::iterator on;
|
|
for(on = node.out.begin(), fragment = node.frags.begin(); on != node.out.end(); ++on, ++fragment) {
|
|
if((*on)->visited) continue;
|
|
|
|
if(error < (*on)->error) { //need to expand this node.
|
|
qnodo.push(*on);
|
|
(*on)->visited = 1;
|
|
} else {
|
|
vector<Cell *>::iterator cell;
|
|
for(cell=(*fragment).begin(); cell != (*fragment).end(); ++cell)
|
|
selected.push_back(*cell);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//custom extraction
|
|
template <class CONT, class POLICY> void Extract(CONT &selected, POLICY &policy) {
|
|
std::vector<Node>::iterator n;
|
|
for(n = nodes.begin(); n != nodes.end(); n++)
|
|
(*n).visited = false;
|
|
|
|
std::queue<Node *> qnodo;
|
|
qnodo.push(&nodes[0]);
|
|
nodes[0].visited = true;
|
|
|
|
for( ; !qnodo.empty(); qnodo.pop()) {
|
|
Node &node = *qnodo.front();
|
|
|
|
std::vector<Frag>::iterator i;
|
|
std::vector<Node *>::iterator on;
|
|
for(i = node.frags.begin(), on = node.out.begin(); i != node.frags.end(); i++, on++) {
|
|
if((*on)->visited) continue;
|
|
Frag &frag = (*i);
|
|
std::vector<Cell *>::iterator cell;
|
|
for(cell = frag.begin(); cell != frag.end(); cell++) {
|
|
if(policy.Expand(*cell))
|
|
visit(*on, qnodo);
|
|
}
|
|
}
|
|
}
|
|
Extract(selected);
|
|
}
|
|
|
|
//extract using a user class which must provides:
|
|
//bool refineCell(Cell *cell, Frustum &frustum);
|
|
//void addCell(Cell *cell);
|
|
//void removeCell(Cell *cell);
|
|
//template <class CONT> void extract(std::vector<Cell *> &selected, Frustum &frustum, T &error);
|
|
|
|
///extract using the visited flag in nodes to a STL container of Cell *
|
|
template <class CONT> void Extract(CONT &selected) {
|
|
selected.clear();
|
|
std::vector<Node>::iterator i;
|
|
for(i = nodes.begin(); i != nodes.end(); i++) {
|
|
Node &node = *i;
|
|
if(!node.visited)
|
|
continue;
|
|
|
|
std::vector<Node *>::iterator n;
|
|
std::vector<Frag>::iterator f;
|
|
for(n = node.out.begin(), f = node.frags.begin(); n != node.out.end(); n++, f++) {
|
|
if(!(*n)->visited || (*n)->error == 0) {
|
|
vector<Cell *>::iterator c;
|
|
Frag &frag = (*f);
|
|
for(c = frag.begin(); c != frag.end(); c++)
|
|
selected.insert(selected.end(), *c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
///add a node to the queue recursively mantaining coherence.
|
|
void Visit(Node *node, std::queue<Node *> &qnode) {
|
|
std::vector<Node *>::iterator n;
|
|
for(n = node->in.begin(); n != node->in.end(); n++)
|
|
if(!(*n)->visited)
|
|
visit(*n, qnode);
|
|
|
|
node->visited = true;
|
|
qnode.push(node);
|
|
}
|
|
|
|
|
|
};
|
|
|
|
template <class C> class FrustumPolicy {
|
|
public:
|
|
typedef C Cell;
|
|
|
|
Frustumf frustum;
|
|
///target error in screen space (pixels)
|
|
float error;
|
|
|
|
bool Expand(Cell *cell) {
|
|
if(cell->Error() == 0) return false;
|
|
float dist = Distance(*cell, frustum.ViewPoint());
|
|
/*Point3f line = frustum.viewPoint() - cell->sphere.center;
|
|
float dist = line.Norm() - cell->sphere.radius; */
|
|
if(dist < 0) return true;
|
|
dist = pow(dist, 1.2);
|
|
float res = cell->Error() / (frustum.Resolution()*dist);
|
|
return res;
|
|
}
|
|
};
|
|
|
|
///really simple example policy
|
|
template <class C> class DiracPolicy {
|
|
public:
|
|
typedef C Cell;
|
|
|
|
Point3f focus;
|
|
///max error in object space at distance 0
|
|
float error;
|
|
|
|
DiracPolicy(Point3f &f = Point3f(0, 0, 0), float e = 0): focus(f), error(e) {}
|
|
|
|
bool Expand(Cell *cell) {
|
|
if(cell->Error() == 0) return false;
|
|
float dist = Distance(*cell, focus);
|
|
if(dist > 0) return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
}//namespace vcg
|
|
|
|
#endif |