manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/apps/nexus/extraction.cpp

486 lines
14 KiB
C++
Raw Blame History

/****************************************************************************
* 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 $
Revision 1.12 2005/03/02 10:40:17 ponchio
Extraction rewrittten (to fix recusive problems).
Revision 1.11 2005/02/20 19:49:44 ponchio
cleaning (a bit more).
Revision 1.10 2005/02/20 18:07:00 ponchio
cleaning.
Revision 1.9 2005/02/20 00:43:23 ponchio
Less memory x extraction. (removed frags)
Revision 1.8 2005/02/19 16:22:45 ponchio
Minor changes (visited and Cell)
Revision 1.7 2005/02/10 09:18:20 ponchio
Statistics.
Revision 1.6 2005/02/08 12:43:03 ponchio
Added copyright
****************************************************************************/
#include "extraction.h"
#include "metric.h"
#include "nexus.h"
#include <algorithm>
using namespace std;
using namespace nxs;
/* Updateing strategy:
if i can refine (not at leaves,
have draw and extr buffer,
not past target_error)
i try to refine BUT
i can fail because i finish some buffer
(then i put the operation back on the stack)
if i have finished disk i should just quit
if i cannot refine i consider coarsening:
i need 1) not be at root (eheh)
2) have finished draw and extr buffer
(unless i am at error < target so i want to coarse
3) do not make global error worse
(unless it is error < target_error...)
a stability term is added (1.1) so that we do not flip
nodes in and out quickly
i try to coarse BUT
i can fail because i need disk
(then i put the operation back on the stack)
if i cannt coarse i just quit
*/
Extraction::Extraction(): target_error(4.0f), extr_max(10000),
draw_max(10000), disk_max(100) {
metric = new FrustumMetric;
}
Extraction::~Extraction() {
if(metric) delete metric;
}
void Extraction::SetMetric(Metric *m) {
if(metric)
delete metric;
metric = m;
}
void Extraction::Extract(Nexus *_mt) {
mt = _mt;
root = mt->history.Root();
sink = root + (mt->history.n_nodes()-1);
//clear statistics
extr_used = draw_used = disk_used = 0;
//first we clear the visited flags
visited.clear();
visited.resize(mt->history.n_nodes(), false);
visible.clear();
visible.resize(mt->size(), true);
node_errors.clear();
node_errors.resize(mt->history.n_nodes(), -1);
front.clear();
Visit(root);
while(front.size()) {
pop_heap(front.begin(), front.end());
HeapNode hnode = front.back();
front.pop_back();
Node *node = hnode.node;
if(Visited(node)) continue;
if(Expand(hnode))
Visit(node);
}
Select();
draw_size = selected.size();
}
void Extraction::Init() {
//I want to add all coarsable nodes
//and all refinable node (being careful about recursive dependencies)
for(Node *node = root; node != sink; node++) {
if(!Visited(node)) continue;
if(node != root && CanCoarse(node))
back.push_back(HeapNode(node, GetNodeError(node)));
for(Node::iterator n = node->out_begin; n != node->out_end; n++) {
Node *child = n->node;
if(Visited(child)) continue;
if(node_errors[child - root] != -1) continue; //already visited
float *error = GetNodeError(child);
if(CanRefine(node)) // TODO? && error > target_error
front.push_back(HeapNode(child, error));
if(*error > max_error) max_error = *error;
}
}
//recursively fix error
for(Node *node = root; node != sink; node++)
if(node_errors[node - root] != -1)
SetError(node, node_errors[node-root]);
//estimate cost of all the cut arcs (i need the visible info)
Cost cost;
for(Node *node = root; node != sink; node++) {
if(!Visited(node)) continue;
for(Node::iterator n = node->out_begin; n != node->out_end; n++) {
Link &link = *n;
if(Visited((*n).node)) continue;
for(unsigned int patch = link.begin; patch != link.end; patch++) {
Entry &entry = (*mt)[patch];
cost.extr += entry.ram_size;
if(Visible(patch)) cost.draw += entry.ram_size;
if(!entry.patch) cost.disk += entry.disk_size;
}
}
}
make_heap(front.begin(), front.end());
make_heap(back.begin(), back.end(), greater<HeapNode>());
extr_used = cost.extr;
draw_used = cost.draw;
disk_used = cost.disk;
}
void Extraction::Update(Nexus *_mt) {
mt = _mt;
root = mt->history.Root();
sink = mt->history.Sink();
if(!visited.size()) {
visited.resize(mt->history.n_nodes(), false);
SetVisited(root, true);
}
visible.clear();
visible.resize(mt->size(), true);
node_errors.clear();
node_errors.resize(mt->history.n_nodes(), -1);
front.clear();
back.clear();
max_error = -1;
Init();
bool can_refine = true;
while(1) {
while(can_refine) { //we have available budget
if(!front.size()) break; //we are at max level
if(*front[0].error < target_error) break; //already at target_error
max_error = *front[0].error;
pop_heap(front.begin(), front.end());
HeapNode hnode = front.back();
front.pop_back();
if(!Visited(hnode.node) && CanRefine(hnode.node)) {
if(!Refine(hnode)) {
can_refine = false;
front.push_back(hnode);
push_heap(front.begin(), front.end());
}
}
}
if(!back.size()) //nothing to coarse (happen only on extr_max < root.extr)
break;
if(*back.front().error >= target_error &&
(!front.size() ||
(*back.front().error * 1.4) >= *front.front().error))
break;
pop_heap(back.begin(), back.end(), greater<HeapNode>());
HeapNode hnode = back.back();
back.pop_back();
if(Visited(hnode.node) && //not already coarsed
CanCoarse(hnode.node) && //all children !visited
!Coarse(hnode)) { //no more disk
back.push_back(hnode);
push_heap(back.begin(), back.end(), greater<HeapNode>());
break;
}
can_refine = true;
}
Select();
draw_size = selected.size();
//Preloading now
for(unsigned int i = 0; i < 1000; i++) {
if(!front.size() && !back.size()) break;
if((i%2) && front.size()) {
pop_heap(front.begin(), front.end());
HeapNode hnode = front.back();
Node *node = hnode.node;
front.pop_back();
Node::iterator l;
for(l = node->out_begin; l != node->out_end; l++) {
Link &link = (*l);
for(unsigned int k = link.begin; k != link.end; k++) {
selected.push_back(Item(k, i));
}
}
} else if(back.size()) {
pop_heap(back.begin(), back.end(), greater<HeapNode>());
HeapNode hnode = back.back();
Node *node = hnode.node;
back.pop_back();
for(Node::iterator l = node->in_begin; l != node->in_end; l++) {
Link &link = (*l);
for(unsigned int k = link.begin; k != link.end; k++) {
selected.push_back(Item(k, i));
}
}
}
}
}
float *Extraction::GetNodeError(Node *node) {
float &maxerror = node_errors[node-root];
for(Node::iterator i = node->in_begin; i != node->in_end; i++) {
Link &link = *i;
for(unsigned int p = link.begin; p != link.end; p++) {
Entry &entry = (*mt)[p];
bool visible;
float error = metric->GetError(entry, visible);
// cerr << "Error for patch: " << p << " -> " << error << endl;
if(error > maxerror) maxerror = error;
SetVisible(p, visible);
}
}
return &maxerror;
}
bool Extraction::Refine(HeapNode hnode) {
Node *node = hnode.node;
Cost cost;
Diff(node, cost);
if(disk_used + cost.disk > disk_max ||
extr_used + cost.extr > extr_max ||
draw_used + cost.draw > draw_max)
return false;
extr_used += cost.extr;
draw_used += cost.draw;
disk_used += cost.disk;
SetVisited(node, true);
//now add to the front children (unless sink node)
for(Node::iterator i = node->out_begin; i != node->out_end; i++) {
Link &link = *i;
if(link.node == sink) continue;
float *error = &node_errors[link.node - root];
if(*error == -1)
error = GetNodeError(link.node);
if(*hnode.error < *error) *hnode.error = *error;
//TODO if(maxerror > target_error)
if(CanRefine((*i).node)) {
front.push_back(HeapNode((*i).node, error));
push_heap(front.begin(), front.end());
}
}
back.push_back(hnode);
push_heap(back.begin(), back.end(), greater<HeapNode>());
return true;
}
bool Extraction::Coarse(HeapNode hnode) {
Node *node = hnode.node;
Cost cost;
Diff(node, cost);
extr_used -= cost.extr;
draw_used -= cost.draw;
disk_used -= cost.disk;
if(disk_used > disk_max) return false;
SetVisited(node, false);
//now add to the back parents (unless root node)
for(Node::iterator i = node->in_begin; i != node->in_end; i++) {
Link &link = *i;
if(link.node == root) continue;
float *error = &node_errors[link.node - root];
if(*error == -1)
error = GetNodeError(link.node);
if(*error < *hnode.error) *error = *hnode.error;
if(CanCoarse(link.node)) {
back.push_back(HeapNode(link.node, error));
push_heap(back.begin(), back.end(), greater<HeapNode>());
}
}
front.push_back(hnode);
push_heap(front.begin(), front.end());
return true;
}
void Extraction::Select() {
selected.clear();
Node *root = mt->history.Root();
Node *nodes = mt->history.nodes;
for(unsigned int i = 0; i < visited.size(); i++) {
if(!visited[i]) continue;
Node &node = nodes[i];
Node::iterator n;
for(n = node.out_begin; n != node.out_end; n++) {
unsigned int n_out = (*n).node - root;
if(!visited[n_out]) {
Link &link = *n;
for(unsigned int p = link.begin; p != link.end; p++) {
selected.push_back(Item(p, 0));
}
}
}
}
}
void Extraction::Visit(Node *node) {
assert(!Visited(node));
SetVisited(node, true);
for(Node::iterator i = node->in_begin; i != node->in_end; i++) {
if(Visited((*i).node)) continue;
Visit((*i).node);
}
Cost cost;
Diff(node, cost);
extr_used += cost.extr;
draw_used += cost.draw;
disk_used += cost.disk;
for(Node::iterator i = node->out_begin; i != node->out_end; i++) {
float maxerror = -1;
Link &link = *i;
for(unsigned int p = link.begin; p != link.end; p++) {
Entry &entry = (*mt)[p];
bool visible;
float error = metric->GetError(entry, visible);
if(error > maxerror) maxerror = error;
SetVisible(p, visible);
}
//TODO this check may be dangerous for non saturating things...
if(maxerror > target_error) {
node_errors[(*i).node - root] = maxerror;
HeapNode hnode((*i).node, &node_errors[(*i).node - root]);
front.push_back(hnode);
push_heap(front.begin(), front.end());
}
}
}
bool Extraction::Expand(HeapNode &node) {
if(extr_used >= extr_max) return false;
if(draw_used >= draw_max) return false;
// if(disk_used >= disk_max) return false;
return *node.error > target_error;
}
void Extraction::Diff(Node *node, Cost &cost) {
Node::iterator i;
for(i = node->in_begin; i != node->in_end; i++) {
Link &link = *i;
for(unsigned int p = link.begin; p != link.end; p++) {
Entry &entry = (*mt)[p];
cost.extr -= entry.ram_size;
if(Visible(p)) cost.draw -= entry.ram_size;
if(!entry.patch) cost.disk -= entry.disk_size;
}
}
for(i = node->out_begin; i != node->out_end; i++) {
Link &link = *i;
for(unsigned int p = link.begin; p != link.end; p++) {
Entry &entry = (*mt)[p];
cost.extr += entry.ram_size;
if(Visible(p)) cost.draw += entry.ram_size;
if(!entry.patch) cost.disk += entry.disk_size;
}
}
}
void Extraction::SetError(Node *node, float error) {
for(Node::iterator i = node->in_begin; i != node->in_end; i++)
if(node_errors[(*i).node - root] != -1 &&
node_errors[(*i).node - root] < error) {
node_errors[(*i).node - root] = error;
SetError((*i).node, error);
}
}
bool Extraction::CanRefine(Node *node) {
for(Node::iterator i = node->in_begin; i != node->in_end; i++)
if(!Visited((*i).node))
return false;
return true;
}
bool Extraction::CanCoarse(Node *node) {
for(Node::iterator i = node->out_begin; i != node->out_end; i++)
if(Visited((*i).node))
return false;
return true;
}
Reference in New Issue View Git Blame Copy Permalink