vcglib/apps/nexus/nxsbuild.cpp

#include "nxsbuild.h"
#include <set>
#include <map>
#include <iostream>

using namespace nxs;
using namespace vcg;
using namespace std;

void nxs::RemapVertices(Crude &crude,
			VertRemap &vert_remap,
			VFile<unsigned int> &face_remap,	 
			vector<unsigned int> &patch_verts) {

  for(unsigned int i = 0; i < crude.Faces(); i++) {
    Crude::Face &face = crude.GetFace(i);
    unsigned int patch = face_remap[i];
    for(int k = 0; k < 3; k++) {
      set<unsigned int> pp;
      vert_remap.GetValues(face[k], pp);
      if(!pp.count(patch)) {
	      vert_remap.Insert(face[k], patch);      
	      patch_verts[patch]++;
      }
    }
  }
}

void nxs::NexusAllocate(Crude &crude,
			Nexus &nexus,
			VFile<unsigned int> &face_remap,
			vector<unsigned int> &patch_faces,
			vector<unsigned int> &patch_verts) {
  
  
  nexus.index.resize(patch_faces.size());
  
  //  unsigned int totchunks = 0;
  //now that we know various sizes, lets allocate space
  cerr << "Fixing entries\n";
  for(unsigned int i = 0; i < nexus.index.size(); i++) {
    Nexus::PatchInfo &entry = nexus.index[i];
    
    if(patch_faces[i] == 0 || patch_verts[i] == 0) 
      cerr << "Warning! Empty patch.\n";

    nexus.patches.AddPatch(patch_verts[i], patch_faces[i]);

    entry.nvert = patch_verts[i];
    entry.nface = patch_faces[i];
    entry.error = 0;    
  }

  patch_faces.clear();
  patch_faces.resize(nexus.index.size(), 0);

  //now we sort the faces into the patches (but still using absolute indexing
  //instead of relative indexing
  cerr << "Moving faces into patches\n";

  for(unsigned int i = 0; i < crude.face.Size(); i++) {
    Crude::Face &face = crude.face[i];
    unsigned int npatch = face_remap[i];
#ifdef CONTROLS
    if(npatch > nexus.index.size()) {
      cerr << "INvalid index\n";
      exit(0);
    }
#endif
    Nexus::PatchInfo &entry = nexus.index[npatch];    
    //TODO this is slow because we have to initialize patch.
    //just get patch.start.
    Patch patch = nexus.GetPatch(npatch);
    
    Crude::Face *faces = (Crude::Face *)patch.start;

    //REMOVING degenerate faces
    if(face[0] == face[1] || face[1] == face[2] || face[0] == face[2]) {
      cerr << "Found degenerate.\n";
      continue;
    }
#ifdef CONTROLS
    if(patch_faces[npatch] > entry.nface) {
      cerr << "patch_faces[npatch]: " << patch_faces[npatch] 
      << " should be <= " << entry.nface << endl;
      cerr << "something not workin here!\n";
      exit(0);
    }    
#endif
    faces[patch_faces[npatch]++] = face;
  }
  cerr << "Fixing entry faces\n";
  for(unsigned int i = 0; i < nexus.index.size(); i++) {
    Nexus::PatchInfo &entry = nexus.index[i];
    entry.nface = patch_faces[i];
  }
}

void nxs::NexusFill(Crude &crude,
		    Nexus &nexus,
		    VertRemap &vert_remap,
		    VFile<RemapLink> &border_remap) {
  

  //TODO: is it faster to collect faces and vertices
  //from all around or better to pass linearly all the dataset
  //and write where needed? i wonder.
  //finally for every patch we collect the vertices
  //and fill the patch.
  //we need to remember start and size in border_remap;
  
  for(unsigned int i = 0; i < nexus.index.size(); i++) {
    Patch patch = nexus.GetPatch(i);
    Nexus::PatchInfo &entry = nexus.index[i];
    
    //make a copy of faces (we need to write there :P)
    Crude::Face *faces = new Crude::Face[patch.nf];
    //Test for degenerate faces?
    memcpy(faces, (Crude::Face *)patch.start,
	   patch.nf * sizeof(Crude::Face));
    
    //collect all vertices we need.
    //TODO an hash_map would be faster?
    unsigned int count = 0;
    map<unsigned int, unsigned short> remap;

    assert(patch.nf != 0);
    for(unsigned int k = 0; k < patch.nf; k++) {
      Crude::Face &face = faces[k];
      for(int j = 0; j < 3; j++) {
        if(!remap.count(face[j])) {          
	  Point3f &v = crude.vert[face[j]];
          patch.Vert(remap.size()) = v;
	  entry.sphere.Add(v);
          remap[face[j]] = count++;
        }
	patch.Face(k)[j] = remap[face[j]];
      }
    }
    assert(count == remap.size());
    assert(entry.nvert == remap.size());
    
    //record start of border:
    unsigned int border_start = border_remap.Size();
    
    //TODO hash_set?
    set<unsigned int> border_patches;
    map<unsigned int, unsigned short>::iterator m;
    for(m = remap.begin(); m != remap.end(); m++) {
      RemapLink link;
      link.abs_vert = (*m).first;
      link.rel_vert = (*m).second;
      
      vert_remap.GetValues(link.abs_vert, border_patches);
      assert(border_patches.size() >= 1);
      if(border_patches.size() == 1) continue; //its not a border
      
      set<unsigned int>::iterator s;
      for(s = border_patches.begin(); s != border_patches.end(); s++) {
	if((*s) == i) continue; 
	link.patch = *s;
	border_remap.PushBack(link);
      }
    }
    unsigned int needed = border_remap.Size() - border_start;
    nexus.borders.AddBorder(2 * needed, needed);
    delete []faces;
  }

  //we can now update bounding sphere.
  for(unsigned int i = 0; i < nexus.index.size(); i++) 
    nexus.sphere.Add(nexus.index[i].sphere);

  //and last convert RemapLinks into Links

  //TODO probably this part is really slow
  for(unsigned int i = 0; i < nexus.borders.borders.size(); i++) {
    BorderEntry &local = nexus.borders.borders[i];
    //* 2 is to accomodate future borders
    unsigned int remap_start = local.border_start/2;

    // K is the main iterator (where we write to in nexus.borders)
    for(unsigned int k = 0;  k < local.border_used; k++) {
      
      
      RemapLink start_link = border_remap[k + remap_start];
      
      BorderEntry &remote = nexus.borders.borders[start_link.patch];

      bool found = false;

      unsigned int remote_remap_start = remote.border_start/2;
      for(unsigned int j = 0; j < remote.border_used; j++) {
	
	RemapLink end_link = border_remap[j + remote_remap_start];
	//	assert(end_link.rel_vert < remote.nvert);

	if(start_link.abs_vert == end_link.abs_vert &&
	   end_link.patch == i) { //found the match
	  //	  assert(!found);
	  nexus.borders[k + local.border_start] = Link(start_link.rel_vert, 
						      end_link.rel_vert, 
						      start_link.patch);
	  found = true;
	}
      }
    }
  }
  nexus.borders.Flush();

  //Checking border consistency:
  /*  for(unsigned int i = 0; i < nexus.index.size(); i++) {
    Border border = nexus.GetBorder(i);
    Nexus::PatchInfo &entry = nexus.index[i];
    for(unsigned int k = 0; k < border.Size(); k++) {
      Link &link = border[k];
      if(link.start_vert >= entry.nvert) {
	cerr << "K: " << k << endl;
	cerr << "patch: " << i << " nvert: " << entry.nvert << " startv: " 
	     << link.start_vert << endl;
	//	cerr << "bstart: " << entry.border_start 
	//	     << "bsize: " << entry.border_size << endl;
      }
      assert(link.end_patch < nexus.index.size());
      assert(link.start_vert < entry.nvert);
      Nexus::PatchInfo &remote = nexus.index[link.end_patch];
      assert(link.end_vert < remote.nvert);
    }
    }*/
}