493 lines
14 KiB
C++
493 lines
14 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 $
|
|
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 "nexusmt.h"
|
|
|
|
#include <algorithm>
|
|
|
|
using namespace std;
|
|
using namespace nxs;
|
|
|
|
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::Extract(NexusMt *_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);
|
|
|
|
heap.clear();
|
|
|
|
Visit(root);
|
|
|
|
while(heap.size()) {
|
|
pop_heap(heap.begin(), heap.end());
|
|
HeapNode hnode = heap.back();
|
|
heap.pop_back();
|
|
|
|
Node *node = hnode.node;
|
|
if(Visited(node)) continue;
|
|
|
|
if(Expand(hnode))
|
|
Visit(node);
|
|
}
|
|
Select();
|
|
draw_size = selected.size();
|
|
}
|
|
|
|
void Extraction::Init() {
|
|
max_error = -1;
|
|
front.clear();
|
|
back.clear();
|
|
errors.clear();
|
|
|
|
Cost cost;
|
|
|
|
Node *nodes = mt->history.nodes;
|
|
for(unsigned int i = 0; i < visited.size(); i++) {
|
|
if(!visited[i]) continue;
|
|
Node &node = nodes[i];
|
|
|
|
bool cancoarse = true;
|
|
|
|
Node::iterator n;
|
|
for(n = node.out_begin; n != node.out_end; n++) {
|
|
if(!Visited((*n).node)) {
|
|
float maxerror = -1;
|
|
|
|
Link &link = *n;
|
|
for(unsigned int patch = link.begin; patch != link.end; patch++) {
|
|
Entry &entry = (*mt)[patch];
|
|
|
|
bool visible;
|
|
float error = metric->GetError(entry, visible);
|
|
if(error > maxerror) maxerror = error;
|
|
|
|
cost.extr += entry.ram_size;
|
|
|
|
SetVisible(patch, visible);
|
|
if(visible)
|
|
cost.draw += entry.ram_size;
|
|
|
|
if(!entry.patch)
|
|
cost.disk += entry.disk_size;
|
|
}
|
|
if((*n).node != sink && maxerror > target_error)
|
|
front.push_back(HeapNode((*n).node, maxerror));
|
|
if(maxerror > max_error) max_error = maxerror;
|
|
} else
|
|
cancoarse = false;
|
|
}
|
|
if(cancoarse && (&node != root)) {
|
|
float error = GetRefineError(&node);
|
|
back.push_back(HeapNode(&node, error));
|
|
}
|
|
}
|
|
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(NexusMt *_mt) {
|
|
mt = _mt;
|
|
root = mt->history.Root();
|
|
sink = root + (mt->history.n_nodes()-1);
|
|
//clear statistics
|
|
|
|
if(!visited.size()) {
|
|
visited.resize(mt->history.n_nodes(), false);
|
|
SetVisited(root, true);
|
|
}
|
|
visible.clear();
|
|
visible.resize(mt->size(), true);
|
|
|
|
Init();
|
|
|
|
bool no_draw = false;
|
|
|
|
//TODO big problem: nodes a (error 10) with parent b (error -1)
|
|
//i try to refine a, refine b (recursive) but fail to refine a
|
|
//next step i coarse b whis cause a cycle.
|
|
|
|
/* 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 (exp. while recursively refine)
|
|
(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
|
|
3) do not make global error worse (unless it is < target_error...)
|
|
4) check it is not a recursive coarsening (drop it otherwise)
|
|
i try to coarse BUT
|
|
i can fail because i need disk
|
|
(then i put the operation back on the stack)
|
|
if i cannot coarse i just quit
|
|
*/
|
|
|
|
while(1) {
|
|
if(!no_draw && //we have buffer
|
|
front.size() && //we are not at max level
|
|
front[0].error > target_error) { //we are not 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) && !Refine(hnode))
|
|
no_draw = true;
|
|
|
|
continue;
|
|
}
|
|
|
|
if(!back.size()) {
|
|
//cerr << "nothing to coarse!\n";
|
|
break; //nothing to coarse (happen only on extr_max < root.extr
|
|
}
|
|
|
|
if(no_draw) { //suppose i have no more buffer
|
|
//TODO see point 3
|
|
//if i do error damages coarsening better get out
|
|
if(front.size() && ((back.front().error + 0.001) >= front.front().error)) {
|
|
//cerr << "Balanced cut\n";
|
|
break;
|
|
}
|
|
if(!front.size() && back.front().error >= target_error) {
|
|
//cerr << "Maxed out\n";
|
|
break;
|
|
}
|
|
}
|
|
|
|
//nothing to refine, coarse only if error <= target_error
|
|
if(!no_draw && back.front().error >= target_error) {
|
|
//cerr << "error dominating\n";
|
|
break;
|
|
}
|
|
|
|
|
|
pop_heap(back.begin(), back.end(), greater<HeapNode>());
|
|
HeapNode hnode = back.back();
|
|
back.pop_back();
|
|
if(Visited(hnode.node)) {
|
|
bool recursive = false;
|
|
Node::iterator i;
|
|
for(i = hnode.node->out_begin; i != hnode.node->out_end; i++) {
|
|
Node *child = (*i).node;
|
|
if(Visited(child)) recursive = true;
|
|
}
|
|
if(!recursive && !Coarse(hnode)) { //no more disk so. push back on heap the heapnode
|
|
back.push_back(hnode);
|
|
push_heap(back.begin(), back.end(), greater<HeapNode>());
|
|
break;
|
|
}
|
|
}
|
|
|
|
no_draw = false;
|
|
}
|
|
|
|
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));
|
|
errors[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));
|
|
errors[k] = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
float Extraction::GetRefineError(Node *node) {
|
|
float maxerror = -1;
|
|
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);
|
|
if(error > maxerror) maxerror = error;
|
|
SetVisible(p, visible);
|
|
}
|
|
}
|
|
return maxerror;
|
|
}
|
|
|
|
bool Extraction::Refine(HeapNode hnode) {
|
|
|
|
Node *node = hnode.node;
|
|
|
|
//recursively refine parent if applicable.
|
|
for(Node::iterator i = node->in_begin; i != node->in_end; i++) {
|
|
Node *parent = (*i).node;
|
|
if(!Visited(parent)) {
|
|
//Here i use parent refine error!!!
|
|
if(!Refine(HeapNode(parent, hnode.error))) return false;
|
|
}
|
|
}
|
|
|
|
Cost cost;
|
|
Diff(node, cost);
|
|
|
|
bool failed = false;
|
|
if(disk_used + cost.disk > disk_max) {
|
|
//cerr << "Disk failed\n";
|
|
failed = true;
|
|
}
|
|
if(extr_used + cost.extr > extr_max) {
|
|
//cerr << "Extr failed\n";
|
|
failed = true;
|
|
}
|
|
if(draw_used + cost.draw > draw_max) {
|
|
//cerr << "Draw failed\n";
|
|
failed = true;
|
|
}
|
|
|
|
if(failed) {
|
|
front.push_back(hnode);
|
|
push_heap(front.begin(), front.end());
|
|
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 maxerror = GetRefineError(link.node);
|
|
|
|
if(maxerror > target_error)
|
|
front.push_back(HeapNode((*i).node, maxerror));
|
|
}
|
|
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) {
|
|
//cerr << "Coarse node: " << (void *)hnode.node << " err: " << hnode.error << endl;
|
|
Node *node = hnode.node;
|
|
|
|
//recursively coarse children if applicable.
|
|
for(Node::iterator i = node->out_begin; i != node->out_end; i++) {
|
|
Node *child = (*i).node;
|
|
float error = GetRefineError(child);
|
|
HeapNode hchild(child, error);
|
|
if(Visited(child)) {
|
|
if(!Coarse(hchild)) return false;
|
|
}
|
|
}
|
|
|
|
|
|
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 maxerror = GetRefineError(link.node);
|
|
|
|
back.push_back(HeapNode(link.node, maxerror));
|
|
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));
|
|
errors[p] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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) {
|
|
HeapNode hnode((*i).node, maxerror);
|
|
heap.push_back(hnode);
|
|
push_heap(heap.begin(), heap.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;
|
|
}
|
|
}
|
|
}
|
|
|