397 lines
11 KiB
C++
397 lines
11 KiB
C++
#include <assert.h>
|
|
|
|
#include <iostream>
|
|
#include <set>
|
|
|
|
#include "nexus.h"
|
|
|
|
using namespace std;
|
|
using namespace vcg;
|
|
using namespace nxs;
|
|
|
|
Nexus::~Nexus() {
|
|
Close();
|
|
}
|
|
|
|
bool Nexus::Create(const string &file, Signature sig, unsigned int c_size) {
|
|
signature = sig;
|
|
totvert = 0;
|
|
totface = 0;
|
|
sphere = Sphere3f();
|
|
chunk_size = c_size;
|
|
unsigned int header_size = 256;
|
|
if(chunk_size > header_size) header_size = chunk_size;
|
|
|
|
history.Clear();
|
|
ram_used = 0;
|
|
ram_max = 50 * (1<<20) / chunk_size;
|
|
|
|
if(!IndexFile<Entry>::Create(file + ".nxp", header_size)) {
|
|
cerr << "Could not create file: " << file << ".nxp" << endl;
|
|
return false;
|
|
}
|
|
|
|
//Important: chunk_size must be 1 so that i can use Region in VFile.
|
|
if(!borders.Create(file + ".nxb")) {
|
|
cerr << "Could not create file: " << file << ".nxb" << endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
bool Nexus::Load(const string &file, bool rdonly) {
|
|
if(!IndexFile<Entry>::Load(file + ".nxp", rdonly)) return false;
|
|
ram_used = 0;
|
|
ram_max = 50 * (1<<20) / chunk_size;
|
|
|
|
history.Clear();
|
|
SetPosition(history_offset);
|
|
unsigned int history_size;
|
|
ReadBuffer(&history_size, sizeof(unsigned int));
|
|
|
|
char *buffer = new char[history_size];
|
|
ReadBuffer(buffer, history_size);
|
|
|
|
if(!history.Load(history_size, buffer)) {
|
|
cerr << "Error loading history\n";
|
|
return false;
|
|
}
|
|
|
|
borders.Load(file + ".nxb", rdonly);
|
|
//TODO on nxsbuilder assure borders are loaded
|
|
return true;
|
|
}
|
|
|
|
void Nexus::Close() {
|
|
if(!Opened()) return;
|
|
|
|
Flush();
|
|
|
|
if(!IsReadOnly()) {
|
|
//set history_offset
|
|
if(!size()) history_offset = 0;
|
|
else
|
|
history_offset = (back().patch_start + back().disk_size);
|
|
history_offset *= chunk_size;
|
|
|
|
unsigned int history_size;
|
|
char *mem = history.Save(history_size);
|
|
Redim(history_offset + history_size + sizeof(unsigned int));
|
|
SetPosition(history_offset);
|
|
WriteBuffer(&history_size, sizeof(unsigned int));
|
|
WriteBuffer(mem, history_size);
|
|
delete []mem;
|
|
}
|
|
borders.Close();
|
|
IndexFile<Entry>::Close();
|
|
}
|
|
|
|
void Nexus::SaveHeader() {
|
|
unsigned int magic = 0x3053584e; // nxs0
|
|
WriteBuffer(&magic, sizeof(unsigned int));
|
|
WriteBuffer(&signature, sizeof(unsigned int));
|
|
WriteBuffer(&chunk_size, sizeof(unsigned int));
|
|
WriteBuffer(&offset, sizeof(int64));
|
|
WriteBuffer(&history_offset, sizeof(int64));
|
|
WriteBuffer(&totvert, sizeof(unsigned int));
|
|
WriteBuffer(&totface, sizeof(unsigned int));
|
|
WriteBuffer(&sphere, sizeof(Sphere3f));
|
|
}
|
|
|
|
bool Nexus::LoadHeader() {
|
|
unsigned int magic;
|
|
ReadBuffer(&magic, sizeof(unsigned int));
|
|
if(magic != 0x3053584e) {
|
|
cerr << "Invalid magic. Not a nxs file\n";
|
|
return false;
|
|
}
|
|
ReadBuffer(&signature, sizeof(unsigned int));
|
|
ReadBuffer(&chunk_size, sizeof(unsigned int));
|
|
ReadBuffer(&offset, sizeof(int64));
|
|
ReadBuffer(&history_offset, sizeof(int64));
|
|
ReadBuffer(&totvert, sizeof(unsigned int));
|
|
ReadBuffer(&totface, sizeof(unsigned int));
|
|
ReadBuffer(&sphere, sizeof(Sphere3f));
|
|
return true;
|
|
}
|
|
|
|
void Nexus::Flush(bool all) {
|
|
if(all) {
|
|
std::map<unsigned int, list<unsigned int>::iterator>::iterator i;
|
|
for(i = index.begin(); i != index.end(); i++) {
|
|
unsigned int patch = (*i).first;
|
|
FlushPatch(patch);
|
|
}
|
|
pqueue.clear();
|
|
index.clear();
|
|
} else {
|
|
while(ram_used > ram_max) {
|
|
unsigned int to_flush = pqueue.back();
|
|
pqueue.pop_back();
|
|
index.erase(to_flush);
|
|
FlushPatch(to_flush);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
Patch &Nexus::GetPatch(unsigned int patch, bool flush) {
|
|
Entry &entry = operator[](patch);
|
|
if(index.count(patch)) {
|
|
assert(entry.patch);
|
|
list<unsigned int>::iterator i = index[patch];
|
|
pqueue.erase(i);
|
|
pqueue.push_front(patch);
|
|
index[patch] = pqueue.begin();
|
|
} else {
|
|
while(flush && ram_used > ram_max) {
|
|
unsigned int to_flush = pqueue.back();
|
|
pqueue.pop_back();
|
|
index.erase(to_flush);
|
|
FlushPatch(to_flush);
|
|
}
|
|
assert(!entry.patch);
|
|
entry.patch = LoadPatch(patch);
|
|
pqueue.push_front(patch);
|
|
list<unsigned int>::iterator i = pqueue.begin();
|
|
index[patch] = i;
|
|
}
|
|
return *(entry.patch);
|
|
}
|
|
|
|
Border Nexus::GetBorder(unsigned int patch, bool flush) {
|
|
return borders.GetBorder(patch);
|
|
}
|
|
|
|
/*void Nexus::AddBorder(unsigned int patch, Link &link) {
|
|
Border border = GetBorder(patch);
|
|
|
|
unsigned int pos = border.Size();
|
|
if(pos > 65500) {
|
|
cerr << "Exceding border size!!!\n";
|
|
exit(0);
|
|
}
|
|
if(borders.ResizeBorder(patch, pos+1)) {
|
|
border = GetBorder(patch);
|
|
}
|
|
|
|
assert(border.Available() > pos);
|
|
|
|
border[pos] = link;
|
|
}*/
|
|
|
|
unsigned int Nexus::AddPatch(unsigned int nvert, unsigned int nface,
|
|
unsigned int nbord) {
|
|
|
|
Entry entry;
|
|
entry.patch_start = 0xffffffff;
|
|
entry.ram_size = Patch::ChunkSize(signature, nvert, nface, chunk_size);
|
|
entry.disk_size = 0xffff;
|
|
entry.nvert = nvert;
|
|
entry.nface = nface;
|
|
entry.error = 0;
|
|
//sphere undefined.
|
|
entry.patch = NULL;
|
|
entry.vbo_array = 0;
|
|
entry.vbo_element = 0;
|
|
|
|
push_back(entry);
|
|
|
|
borders.AddBorder(nbord);
|
|
|
|
totvert += nvert;
|
|
totface += nface;
|
|
return size() - 1;
|
|
}
|
|
|
|
/*void Nexus::Unify(float threshold) {
|
|
//TODO what if colors or normals or strips?
|
|
unsigned int duplicated = 0;
|
|
unsigned int degenerate = 0;
|
|
|
|
for(unsigned int p = 0; p < size(); p++) {
|
|
Entry &entry = operator[](p);
|
|
Patch &patch = GetPatch(p);
|
|
|
|
unsigned int vcount = 0;
|
|
map<Point3f, unsigned short> vertices;
|
|
|
|
vector<unsigned short> remap;
|
|
remap.resize(patch.nv);
|
|
|
|
for(unsigned int i = 0; i < patch.nv; i++) {
|
|
Point3f &point = patch.Vert(i);
|
|
|
|
if(!vertices.count(point))
|
|
vertices[point] = vcount++;
|
|
else
|
|
duplicated++;
|
|
|
|
remap[i] = vertices[point];
|
|
}
|
|
assert(vertices.size() <= patch.nv);
|
|
if(vertices.size() == patch.nv) //no need to unify
|
|
continue;
|
|
|
|
vector<Point3f> newvert;
|
|
newvert.resize(vertices.size());
|
|
map<Point3f, unsigned short>::iterator k;
|
|
for(k = vertices.begin(); k != vertices.end(); k++) {
|
|
newvert[(*k).second] = (*k).first;
|
|
}
|
|
|
|
|
|
vector<unsigned short> newface;
|
|
//check no degenerate faces get created.
|
|
for(unsigned int f = 0; f < entry.nface; f++) {
|
|
unsigned short *face = patch.Face(f);
|
|
if(face[0] != face[1] && face[1] != face[2] && face[0] != face[2] &&
|
|
newvert[remap[face[0]]] != newvert[remap[face[1]]] &&
|
|
newvert[remap[face[0]]] != newvert[remap[face[2]]] &&
|
|
newvert[remap[face[1]]] != newvert[remap[face[2]]]) {
|
|
newface.push_back(remap[face[0]]);
|
|
newface.push_back(remap[face[1]]);
|
|
newface.push_back(remap[face[2]]);
|
|
} else {
|
|
degenerate++;
|
|
}
|
|
}
|
|
|
|
//rewrite patch now.
|
|
entry.nvert = newvert.size();
|
|
entry.nface = newface.size()/3;
|
|
patch.Init(signature, entry.nvert, entry.nface);
|
|
|
|
memcpy(patch.VertBegin(), &(newvert[0]), entry.nvert*sizeof(Point3f));
|
|
memcpy(patch.FaceBegin(), &(newface[0]), entry.nface*3*sizeof(short));
|
|
|
|
//testiamo il tutto... TODO remove this of course
|
|
for(unsigned int i =0; i < patch.nf; i++) {
|
|
for(int k =0 ; k < 3; k++)
|
|
if(patch.Face(i)[k] >= patch.nv) {
|
|
cerr <<" Unify has problems\n";
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
//fix patch borders now
|
|
set<unsigned int> close; //bordering pathes
|
|
Border border = GetBorder(p);
|
|
for(unsigned int b = 0; b < border.Size(); b++) {
|
|
if(border[b].IsNull()) continue;
|
|
close.insert(border[b].end_patch);
|
|
border[b].start_vert = remap[border[b].start_vert];
|
|
}
|
|
|
|
set<unsigned int>::iterator c;
|
|
for(c = close.begin(); c != close.end(); c++) {
|
|
Border bord = GetBorder(*c);
|
|
for(unsigned int b = 0; b < bord.Size(); b++) {
|
|
if(bord[b].IsNull()) continue;
|
|
if(bord[b].end_patch == p) {
|
|
bord[b].end_vert = remap[bord[b].end_vert];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//better to compact directly borders than setting them null.
|
|
//finally: there may be duplicated borders
|
|
for(unsigned int p = 0; p < size(); p++) {
|
|
Border border = GetBorder(p);
|
|
set<Link> links;
|
|
for(unsigned int b = 0; b < border.Size(); b++) {
|
|
Link &link = border[b];
|
|
assert(!link.IsNull());
|
|
//if(border[b].IsNull()) continue;
|
|
links.insert(link);
|
|
}
|
|
int count = 0;
|
|
for(set<Link>::iterator k = links.begin(); k != links.end(); k++)
|
|
border[count++] = *k;
|
|
|
|
borders[p].used = links.size();
|
|
}
|
|
|
|
totvert -= duplicated;
|
|
if(duplicated)
|
|
cerr << "Found " << duplicated << " duplicated vertices" << endl;
|
|
if(degenerate)
|
|
cerr << "Found " << degenerate << " degenerate face while unmifying\n";
|
|
}*/
|
|
|
|
Patch *Nexus::LoadPatch(unsigned int idx) {
|
|
assert(idx < size());
|
|
Entry &entry = operator[](idx);
|
|
if(entry.patch) return entry.patch;
|
|
|
|
char *ram = new char[entry.ram_size * chunk_size];
|
|
#ifndef NDEBUG
|
|
if(!ram) {
|
|
cerr << "COuld not allocate ram!\n";
|
|
exit(0);
|
|
}
|
|
#endif
|
|
|
|
Patch *patch = new Patch(signature, ram, entry.nvert, entry.nface);
|
|
|
|
if(entry.patch_start != 0xffffffff) { //was allocated.
|
|
assert(entry.disk_size != 0xffff);
|
|
|
|
MFile::SetPosition((int64)entry.patch_start * (int64)chunk_size);
|
|
|
|
if((signature & NXS_COMPRESSED) == 0) { //not compressed
|
|
MFile::ReadBuffer(ram, entry.disk_size * chunk_size);
|
|
} else {
|
|
unsigned char *disk = new unsigned char[entry.disk_size * chunk_size];
|
|
MFile::ReadBuffer(disk, entry.disk_size * chunk_size);
|
|
|
|
patch->Decompress(entry.ram_size * chunk_size,
|
|
disk, entry.disk_size * chunk_size);
|
|
delete []disk;
|
|
}
|
|
}
|
|
ram_used += entry.ram_size;
|
|
entry.patch = patch;
|
|
return patch;
|
|
}
|
|
|
|
void Nexus::FlushPatch(unsigned int id) {
|
|
Entry &entry = operator[](id);
|
|
assert(entry.patch);
|
|
|
|
if(!MFile::IsReadOnly()) { //write back patch
|
|
if((signature & NXS_COMPRESSED)) {
|
|
unsigned int compressed_size;
|
|
char *compressed = entry.patch->Compress(entry.ram_size * chunk_size,
|
|
compressed_size);
|
|
if(entry.disk_size == 0xffff) {//allocate space
|
|
assert(entry.patch_start == 0xffffffff);
|
|
entry.disk_size = (unsigned int)((compressed_size-1)/chunk_size) + 1;
|
|
entry.patch_start = (unsigned int)(Length()/chunk_size);
|
|
Redim(Length() + entry.disk_size * chunk_size);
|
|
} else {
|
|
//cerr << "OOOOPSPPPS not supported!" << endl;
|
|
exit(-1);
|
|
}
|
|
MFile::SetPosition((int64)entry.patch_start * (int64)chunk_size);
|
|
MFile::WriteBuffer(compressed, entry.disk_size * chunk_size);
|
|
delete []compressed;
|
|
} else {
|
|
if(entry.disk_size == 0xffff) {
|
|
entry.disk_size = entry.ram_size;
|
|
entry.patch_start = (unsigned int)(Length()/chunk_size);
|
|
Redim(Length() + entry.disk_size * chunk_size);
|
|
}
|
|
MFile::SetPosition((int64)entry.patch_start * (int64)chunk_size);
|
|
MFile::WriteBuffer(entry.patch->start, entry.disk_size * chunk_size);
|
|
}
|
|
}
|
|
|
|
delete [](entry.patch->start);
|
|
delete entry.patch;
|
|
entry.patch = NULL;
|
|
ram_used -= entry.ram_size;
|
|
}
|