开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
GenericScan.cc
资源名称：scanalyze-1.0.3_source_code.rar　[点击查看]
上传用户：kellyonhid
上传日期：2013-10-12
资源大小：932k
文件大小：30k
源码类别：

3D图形编程

开发平台：

Visual C++

GenericScan.cc：源码内容
  1. //############################################################
  2. // 
  3. // GenericScan.cc
  4. //
  5. // Kari Pulli
  6. // Mon Jun 29 11:51:05 PDT 1998
  7. //
  8. // Store range scan information from a generic range scanner
  9. // that gives range maps.
  10. // Not much if anything is known of the scanner properties,
  11. // so orthographics scan geometry is assumed.
  12. //
  13. //############################################################
  16. #include <fstream.h>
  17. #include <sys/stat.h>
  18. #include "GenericScan.h"
  19. #include "defines.h"
  20. #include "Mesh.h"
  21. #include "RangeGrid.h"
  22. #include "plvGlobals.h"
  23. #include "plvScene.h"
  24. #include "plvDraw.h"
  25. #include "KDindtree.h"
  26. #include "ColorUtils.h"
  27. #include "TriMeshUtils.h"
  28. #include "FileNameUtils.h"
  29. #include "MeshTransport.h"
  30. #include "VertexFilter.h"
  33. GenericScan::GenericScan ()
  34. {
  35.   _Init();
  36. }
  39. void
  40. GenericScan::_Init()
  41. {
  42.   bDirty = true;
  43.   bNameSet = false;
  44.   pushcount = 0;
  45.   myRangeGrid = NULL;
  46. }
  49. GenericScan::GenericScan (Mesh* mesh, const crope& name)
  50. {
  51.   _Init();
  52.   insertMesh (mesh, name);
  53.   computeBBox();
  54.   set_name (name);
  55. }
  58. GenericScan::~GenericScan ()
  59. {
  60.   while (meshes.size()) {
  61.     delete meshes.back();
  62.     meshes.pop_back();
  63.   }
  64.   
  65.   while (kdtree.size()) {
  66.     delete kdtree.back();
  67.     kdtree.pop_back();
  68.   }
  70.   delete myRangeGrid;
  71. }
  74. MeshTransport*
  75. GenericScan::mesh(bool perVertex, bool stripped,
  76.   ColorSource color, int colorSize)
  77. {
  78.   if (stripped && !perVertex) {
  79.     cerr << "No t-strips without per-vertex properties";
  80.     return NULL;
  81.   }
  83.   Mesh* mesh = currentMesh();
  85.   MeshTransport* mt = new MeshTransport;
  86.   mt->setVtx (&mesh->vtx, MeshTransport::share);
  87.   if (perVertex)
  88.     mt->setNrm (&mesh->nrm, MeshTransport::share);
  89.   else {
  90.     vector<short>* faceNrm = new vector<short>;
  91.     mesh->simulateFaceNormals (*faceNrm);
  92.     mt->setNrm (faceNrm, MeshTransport::steal);
  93.   }
  94.   if (stripped)
  95.     mt->setTris (&mesh->getTstrips(), MeshTransport::share);
  96.   else
  97.     mt->setTris (&mesh->getTris(), MeshTransport::share);
  99.   if (color != colorNone)
  100.     setMTColor (mesh, mt, perVertex, color, colorSize);
  102.   return mt;
  103. }
  106. void
  107. GenericScan::setMTColor (Mesh* mesh, MeshTransport* mt,
  108.  bool perVertex, ColorSource source,
  109.  int colorsize)
  110. {
  111.   if (source == colorBoundary) {
  112.       mesh->mark_boundary_verts();
  113.   } else if (source == colorConf) {
  114.     if (!mesh->vertConfidence)
  115.       return;  // confidence data requested but does not exist
  116.   } else {
  117.     if (!mesh->vertMatDiff && !mesh->vertIntensity &&
  118. (perVertex || !mesh->triMatDiff))
  119.       return;  // no color data at all, or only per-face but per-vert requested
  120.   }
  122.   // we know color data can at the least be synthesized... do it!
  123.   vector<uchar>* colors = new vector<uchar>;
  124.   mt->setColor (colors, MeshTransport::steal);
  126.   if (source == colorConf) {
  127.     if (perVertex) {
  128.       // per-vertex confidence
  129.       colors->reserve (colorsize * mesh->vtx.size());
  130.       for (int i = 0; i < mesh->vtx.size(); i++)
  131. pushConf (*colors, colorsize, mesh->vertConfidence[i]);
  132.     } else {
  133.       // per-face confidence
  134.       colors->reserve (colorsize * mesh->getTris().size()/3);
  135.       for (int i = 0; i < mesh->tris.size(); i+=3) {
  136. pushConf (*colors, colorsize,
  137.   (mesh->vertConfidence[mesh->tris[i+0]]
  138.    + mesh->vertConfidence[mesh->tris[i+1]]
  139.    + mesh->vertConfidence[mesh->tris[i+2]]) / 3);
  140.       }
  141.     }
  142.   } else if (source == colorBoundary) {
  143.       colors->reserve (colorsize * mesh->bdry.size());
  144.       char* end = mesh->bdry.end();
  145.       for (char* c = mesh->bdry.begin(); c < end; c++)
  146. pushConf (*colors, colorsize, (uchar)(*c ? 0 : 255));
  147.   } else { // real diffuse color, not confidence
  148.     if (perVertex) {
  149.       // per-vertex truecolor or intensity
  150.       colors->reserve (colorsize * mesh->vtx.size());
  151.       for (int i = 0; i < mesh->vtx.size(); i++) {
  152. if (source == colorTrue) { // prefer rgb over intensity
  153.   if (mesh->vertMatDiff)
  154.     pushColor (*colors, colorsize, mesh->vertMatDiff[i]);
  155.   else
  156.     pushColor (*colors, colorsize, mesh->vertIntensity[i]);
  157. } else { // prefer intensity over rgb
  158.   if (mesh->vertIntensity)
  159.     pushColor (*colors, colorsize, mesh->vertIntensity[i]);
  160.   else
  161.     pushColor (*colors, colorsize,
  162.        intensityFromRGB (mesh->vertMatDiff[i]));
  163. }
  164.       }
  165.     } else {
  166.       // per-face truecolor or intensity
  167.       colors->reserve (colorsize * mesh->getTris().size()/3);
  168.       for (int i = 0; i < mesh->tris.size(); i+=3) {
  169. if (source == colorTrue) { // prefer rgb from faces,
  170.   // then rgb from verts, then intensity
  171.   if (mesh->triMatDiff)
  172.     pushColor (*colors, colorsize, mesh->triMatDiff[i/3]);
  173.   else if (mesh->vertMatDiff)
  174.     pushColor (*colors, colorsize,
  175.        mesh->vertMatDiff[mesh->tris[i+0]],
  176.        mesh->vertMatDiff[mesh->tris[i+1]],
  177.        mesh->vertMatDiff[mesh->tris[i+2]]);
  178.   else
  179.     pushColor (*colors, colorsize,
  180.        mesh->vertIntensity[mesh->tris[i+0]],
  181.        mesh->vertIntensity[mesh->tris[i+1]],
  182.        mesh->vertIntensity[mesh->tris[i+2]]);
  183. } else { // prefer intensity, then rgb from faces, then rgb from verts
  184.   if (mesh->vertIntensity)
  185.     pushColor (*colors, colorsize,
  186.        mesh->vertIntensity[mesh->getTris()[i+0]],
  187.        mesh->vertIntensity[mesh->tris[i+1]],
  188.        mesh->vertIntensity[mesh->tris[i+2]]);
  189.   else if (mesh->triMatDiff)
  190.     pushColor (*colors, colorsize, mesh->triMatDiff[i/3]);
  191.   else
  192.     pushColor (*colors, colorsize,
  193.        uchar (((int)intensityFromRGB (mesh->vertMatDiff[mesh->getTris()[i+0]])
  194. + intensityFromRGB (mesh->vertMatDiff[mesh->tris[i+1]])
  195. + intensityFromRGB (mesh->vertMatDiff[mesh->tris[i+2]]))/3));
  196. }
  197.       }
  198.     }
  199.   }
  200. }
  203. void
  204. GenericScan::computeBBox()
  205. {
  206.   bool nonEmpty;
  207.   
  208.   bbox.clear();
  209.   for (int i = 0; i < meshes.size(); i++) {
  210.     if (meshes[i]->num_verts() != 0) {
  211.       bbox.add(meshes[i]->bbox);
  212.       nonEmpty = 1;
  213.     }
  214.   }
  215.   
  216.   if (nonEmpty) {
  217.     rot_ctr = bbox.center();
  218.   } else {
  219.     rot_ctr = Pnt3();
  220.   }
  221. }
  223. int
  224. GenericScan::num_vertices(void)
  225. {
  226.   return currentMesh()->num_verts();
  227. }
  229. void 
  230. GenericScan::subsample_points(float rate, vector<Pnt3> &p,
  231.       vector<Pnt3> &n)
  232. { 
  233.   currentMesh()->subsample_points(rate, p, n);
  234. }
  237. bool
  238. GenericScan::read (const crope &fname)
  239. {
  240.   bool success = FALSE;
  242.   // initialize name and remove trailing slash, if it's a directory
  243.   set_name (fname);
  245.   // check if it's a .set file -- or a directory containing a .set
  246.   if ( has_ending(".set") ) {
  247.     success = readSet (fname);
  248.   } else {
  249.     // treat filename as directory name, and look for .set file
  250.     crope fn(get_name());
  251.     fn += crope("/") + get_name() + ".set";
  252.     if (0 == access (fn.c_str(), R_OK)) {
  253.       success = readSet (fn);
  254.       if (success)
  255. set_name(fn);
  256.     }
  257.   }
  259.   // if none of the directory/set forms exist, look for single
  260.   // fully-specified file
  261.   if (!success)
  262.     success = readSingleFile (get_name());
  264.   if (success) {
  265.     // try reading transformation
  266.     pushd();
  267.     TbObj::readXform(get_basename());
  268.     popd();
  270.     bDirty = false;
  271.     bNameSet = true;
  272.   }
  274.   return success;
  275. }
  278. void
  279. GenericScan::setd (const crope& dir, bool bCreate)
  280. {
  281.   char setDir [PATH_MAX];
  282.   strcpy (setDir, dir.c_str());
  283.   char* psep = strrchr (setDir, '/');
  284.   if (psep != NULL) {
  285.     // terminate before filename part
  286.     *psep = 0;
  287.     setdir = setDir;
  288.   } else {
  289.     // default to current directory
  290.     getcwd (setDir, PATH_MAX);
  291.   }
  293.   cout << "Set directory is " << setDir << "/" << endl;
  294.   if (bCreate)
  295.     portable_mkdir (setDir, 00775);
  296. }
  299. void
  300. GenericScan::pushd (void)
  301. {
  302.   //cout << "push: count is " << pushcount << endl;
  303.   if (pushcount++ == 0) {
  304.     assert (pusheddir.empty());
  306.     char szCwd [PATH_MAX];
  307.     getcwd (szCwd, PATH_MAX);
  308.     pusheddir = szCwd;
  310.     chdir (setdir.c_str());
  311.   }
  312. }
  315. void
  316. GenericScan::popd (void)
  317. {
  318.   if (--pushcount == 0) {
  319.     assert (!pusheddir.empty());
  321.     chdir (pusheddir.c_str());
  322.     pusheddir = crope();
  323.   }
  324.   //cout << "pop: count is " << pushcount << endl;
  325. }
  328. bool
  329. GenericScan::readSet (const crope& fn)
  330. {
  331.   //read .set file
  332.   ifstream in (fn.c_str());
  333.   if (in.fail()) {
  334.     cout << "FAILED: " << fn << " does not exist." << endl;
  335.     return false;
  336.   }
  338.   int nMeshes;
  339.   int nDefaultRes;
  341.   in.ignore (20, '=');
  342.   in >> nMeshes;
  343.   in.ignore (20, '=');
  344.   in >> nDefaultRes;
  346.   cout << "Set has " << nMeshes << " meshesn";
  347.   cout << "Default res is " << nDefaultRes << endl;
  349.   // semantics of filenames in set files: relative pathnames are relative
  350.   // to directory containing set file
  351.   setd (fn);
  352.   pushd();
  354.   //read meshes mentioned in .set file
  355.   meshes.clear();
  356.   for (int i = 0; i < nMeshes; i++) {
  357.     char load[20];
  358.     int nRes;
  359.     char path[PATH_MAX];
  361.     in >> load >> nRes >> path;
  363.     bool bPreload = !strcmp (load, "preload");
  364.     if (nRes == nDefaultRes)   //always load the default resolution
  365.       bPreload = true;
  367.     if (bPreload) {  // otherwise leave blank
  368.       Mesh* mesh = readMeshFile (path);
  369.       if (mesh)
  370. insertMesh (mesh, path, true, true, nRes);
  371.       //else
  372.       //cerr << "Mesh " << path 
  373.       //     << " named in .set file does not exist" << endl;
  374.     } else {         // insert dummy mesh
  375.       insertMesh (new Mesh, path, false, false, nRes);
  376.     }
  377.   }
  379.   popd();
  381.   //set default mesh according to .set file
  382.   if (!select_by_count (nDefaultRes))  // didn't find default
  383.     select_coarsest();                 // so set to lowest res
  384.   computeBBox();
  386.   return true;
  387. }
  390. bool 
  391. GenericScan::readSingleFile (const crope& fn)
  392. {
  393.   const char* filename = fn.c_str();
  395.   if (is_range_grid_file(filename)) {
  397.     RangeGrid* rangeGrid = new RangeGrid();
  398.     if (rangeGrid->readRangeGrid(filename) == 0) {
  399.   delete rangeGrid;
  400.   return false;
  401.     }
  403.     int subSamp = 1;
  404.     int nAutoGenRes = 4;
  405.     int iPolys = rangeGrid->numSamples * 2;
  407.     for (int i = 0; i < nAutoGenRes; i++) {
  409.       char name[PATH_MAX];
  410.       strcpy (name, filename);
  411.       char* ext = strrchr (name, '.');
  412.       if (ext == NULL)
  413. ext = name + strlen (name);
  414.       sprintf (ext, "_samp%d.ply", subSamp);
  415.       insertMesh (new Mesh, name, false, false, iPolys / subSamp);
  416.       subSamp *= (SubSampleBase * SubSampleBase);
  417.     }
  419.     myRangeGrid = rangeGrid;
  421.   } else {
  422.     
  423.     Mesh* mesh = readMeshFile (filename);
  424.     if (!mesh)
  425.       return false;
  427.     insertMesh (mesh, filename);
  428.   }
  430.   // set current directory here
  431.   set_name (filename);
  432.   setd();
  434.   select_coarsest();
  435.   computeBBox();
  437.   return true;
  438. }
  441. Mesh*
  442. GenericScan::readMeshFile (const char* name)
  443. {
  444.   Mesh* mesh = new Mesh;
  446.   cout << "Reading mesh " << name << "... " << flush;
  447.   if (!mesh->readPlyFile (name)) {
  448.     cout << "failed!" << endl;
  449.     delete mesh;
  450.     return NULL;
  451.   }
  453.   cout << "calculating normals... " << flush;
  454.   mesh->updateScale();
  455.   mesh->initNormals(UseAreaWeightedNormals);
  456.   cout << "done." << endl;
  458.   return mesh;
  459. }
  462. int
  463. GenericScan::create_resolution_absolute(int budget, Decimator dec)
  464. {
  465.   Mesh *origMesh = highestRes();
  466.   if (origMesh->num_tris() == 0) {
  467.     cerr <<  "No triangles in the original mesh" << endl;
  468.     return 0;
  469.   }
  471.   cerr << "targetSize = " << budget << endl;
  472.   cerr << "num meshes = " << num_resolutions() << endl;
  474.   Mesh *newMesh = origMesh->Decimate(budget, PLACE_OPTIMAL,
  475.      0, 1000, dec);
  476.   char numberEnding[20];
  477.   sprintf(numberEnding, ".%d.ply", newMesh->num_tris());
  478.   cerr << "output vertSize = " << newMesh->num_verts() << endl;
  479.   cerr << "output triSize = " << newMesh->num_tris() << endl;
  480.   newMesh->bNeedsSave = TRUE;   //mark that this is worth keeping
  482.   insertMesh(newMesh, basename + numberEnding);
  483.   computeBBox();
  485.   cerr << "new num meshes = " << num_resolutions() << endl;
  486.   theScene->invalidateDisplayCaches();
  488. #if 0
  489.   for (int i=0; i<meshes.size(); i++) {
  490.     cout << i << endl;
  491.     cout << meshes[i]->num_tris() << endl;
  492.     cout << meshes[i]->num_verts() << endl;
  493.     cout << meshes[i]->vtx[100] << endl;
  494.     cout << meshes[i]->nrm[100] << endl;
  495.     cout << meshes[i]->tris[100] << endl;
  496.   }
  497. #endif
  499.   bDirty = true;
  500.   return newMesh->num_tris();
  501. }
  504. bool
  505. GenericScan::delete_resolution (int nPolys)
  506. {
  507.   int iRes = findLevelForRes (nPolys);
  508.   if (iRes < 0) {
  509.     cerr << "FAILED: Attempt to delete resolution " << nPolys << endl;
  510.     return false;
  511.   }
  513.   delete meshes[iRes];
  514.   meshes.erase (&meshes[iRes]);
  515.   resolutions.erase (&resolutions[iRes]);
  517.   select_coarser();
  518.   return true;
  519. }
  522. void
  523. GenericScan::flipNormals (void)
  524. {
  525.   for (int i = 0; i < meshes.size(); i++)
  526.     meshes[i]->flipNormals();
  527.   bDirty = true;
  528. }
  531. void
  532. GenericScan::insertMesh(Mesh *m, const crope& filename,
  533.     bool bLoaded, bool bAlwaysLoad,
  534.     int nRes)
  535. {
  536.   // insert into resolution vector (sorted by vertex count)
  537.   if (nRes == 0)                  // allow override of
  538.     nRes = m->num_tris();         // temporary resolution
  539.   insert_resolution (nRes, filename, bLoaded, bAlwaysLoad);
  541.   // now add to mesh vector, sorted parallel to resolution vector
  542.   int iPos = findLevelForRes (nRes);
  543.   meshes.insert (&meshes[iPos], m);
  544.   kdtree.insert (&kdtree[iPos], NULL);
  545. }
  548. Mesh*
  549. GenericScan::currentMesh (void)
  550. {
  551.   int i = current_resolution_index();
  552.   if (!resolutions[i].in_memory) {
  553.     load_resolution (i);
  554.   }
  556.   return meshes[i];
  557. }
  560. bool
  561. GenericScan::load_resolution (int i)
  562. {
  563.   if (resolutions[i].in_memory)
  564.     return true;
  566.   Mesh* loaded = NULL;
  568.   if (myRangeGrid) {
  569.     // build mesh from range grid
  570.     int subSamp = 1;
  571.     for (int j = 0; j < i; j++) {
  572.       subSamp *= SubSampleBase;
  573.     }
  574.     loaded = myRangeGrid->toMesh(subSamp, false);
  575.     loaded->updateScale();
  576.     loaded->initNormals(UseAreaWeightedNormals);
  577.     loaded->bNeedsSave = true;
  578.   } else {
  579.     // mesh should be plyfile on disk
  580.     
  581.     pushd();
  582.     loaded = readMeshFile (resolutions[i].filename.c_str());
  583.     if (!loaded) {
  584.       popd();
  585.       return false;
  586.     }
  587.     popd();
  588.   }
  590.   delete meshes[i];
  591.   meshes[i] = loaded;
  592.   resolutions[i].in_memory = true;
  593.   resolutions[i].abs_resolution = loaded->num_tris();
  594.   computeBBox();
  596.   return true;
  597. }
  600. bool
  601. GenericScan::release_resolution (int nPolys)
  602. {
  603.   int iRes = findLevelForRes (nPolys);
  604.   if (iRes < 0) {
  605.     cerr << "FAILD: Attempt to release resolution " << nPolys << endl;
  606.     return false;
  607.   }
  609.   if (!resolutions[iRes].in_memory)
  610.     return true;
  612.   delete meshes[iRes];
  613.   meshes[iRes] = new Mesh;
  614.   resolutions[iRes].in_memory = false;
  615.   return true;
  616. }
  619. bool 
  620. GenericScan::getXformFilename (const char* meshName, char* xfName)
  621. {
  622.   const char* meshFile = meshName;
  623.   const char* dir = setdir.c_str();
  624.   int dirLen = strlen(dir);
  625.   if (dirLen && !strncmp (meshName, dir, dirLen))
  626.     meshFile += dirLen + 1;
  628.   return get_filename_new_ending (meshFile, ".xf", xfName);
  629. }
  632. KDindtree*
  633. GenericScan::get_current_kdtree()
  634. {
  635.   int iTree = current_resolution_index();
  636.   assert (iTree < kdtree.size());
  637.   if (kdtree[iTree] != NULL)
  638.     return kdtree[iTree];
  640.   Mesh* mesh = currentMesh();
  641.   kdtree[iTree] = CreateKDindtree(mesh->vtx.begin(), 
  642.   mesh->nrm.begin(),
  643.   mesh->vtx.size());
  645.   return kdtree[iTree];
  646. }
  649. bool
  650. GenericScan::closest_point(const Pnt3 &p, const Pnt3 &n, 
  651.    Pnt3 &cp, Pnt3 &cn,
  652.    float thr, bool bdry_ok)
  653. {
  654.   KDindtree* tree = get_current_kdtree();
  655.   if (!tree)
  656.     return false;
  658.   int ind, ans;
  659.   Mesh* mesh = currentMesh();
  660.   ans = tree->search(mesh->vtx.begin(), mesh->nrm.begin(), p, n, ind, thr);
  661.   if (ans) {
  662.     if (bdry_ok == 0) {
  663.       // disallow closest points that are on the mesh boundary
  664.       mesh->mark_boundary_verts();
  665.       if (mesh->bdry[ind]) return 0;
  666.     }
  667.     cp = mesh->vtx[ind];
  668.     short *sp = &mesh->nrm[ind*3];
  669.     cn.set(sp[0]/32767.0, 
  670.    sp[1]/32767.0, 
  671.    sp[2]/32767.0);
  672.   }
  673.   return ans;
  674. }
  677. crope
  678. GenericScan::getInfo (void)
  679. {
  680.   char info[512];
  681.   sprintf(info, "Polygon file: %ld resolutionsn"
  682.   "verts %d tris %ld strips %ldnn",
  683.   resolutions.size(),
  684.   currentMesh()->num_verts(), 
  685.   currentMesh()->tris.size() / 3,
  686.   currentMesh()->tstrips.size());
  688.   return crope(info) + RigidScan::getInfo();
  689. }
  692. Mesh*
  693. GenericScan::getMesh (int level)
  694. {
  695.   if (level >= meshes.size())
  696.     level = meshes.size() - 1;
  697.   if (level < 0) level = 0;
  699.   if (!resolutions[level].in_memory)
  700.     load_resolution (level);
  702.   return meshes[level];
  703. }
  706. inline Mesh*
  707. GenericScan::highestRes (void)
  708. {
  709.   return getMesh (0);
  710. }
  712. /* For each triangle in the ply file, this function
  713.    prints out the coordinates of the voxel from which
  714.    it came.  This function is called from plvClipBoxCmds.cc
  715.    which has already called filtered_copy to generate a list
  716.    of the trianlges enclosed by a user-specified box.
  718.    N.B.'s:
  720.    1. This feature should only be called on a *small* set of
  721.    polygons since information is printed out for every polygon
  722.    chosen.
  724.    2. This feature uses the same mechanism as clipping to decide
  725.    which polygons are inside the box.  So, just as clipping returns
  726.    polygons which are inside and facing the box as well as inside
  727.    and facing away from the box, this feature prints information
  728.    for all polygons regardless of whether they are forwards or
  729.    backwards facing.
  731.    - leslie 2001
  732. */
  733. void GenericScan::PrintVoxelInfo()
  734. {
  735.  printf("Printing voxel information...n"); 
  736.  
  737.  Mesh *mesh = currentMesh();
  738.  if (!mesh->hasVoxels) {
  739.    printf("There is no voxel information storedn"); return;
  740.  }
  741.  int triSize = mesh->getTris().size();
  742.  if (triSize != mesh->fromVoxels.size()) {
  743.    printf("Voxel information error: %d tris, %d voxelsn", triSize,
  744.   mesh->fromVoxels.size());
  745.    return;
  746.  }
  748.  for (int i = 0; i < triSize; i += 3) {
  749.    printf("Triangle with vertices atn");
  750.    printf("(%f, %f, %f), (%f, %f, %f), (%f, %f, %f)n",
  751.   mesh->vtx[mesh->tris[i]][0], mesh->vtx[mesh->tris[i]][1],
  752.   mesh->vtx[mesh->tris[i]][2],
  753.   mesh->vtx[mesh->tris[i+1]][0], mesh->vtx[mesh->tris[i+1]][1],
  754.   mesh->vtx[mesh->tris[i+1]][2],
  755.   mesh->vtx[mesh->tris[i+2]][0], mesh->vtx[mesh->tris[i+2]][1],
  756.   mesh->vtx[mesh->tris[i+2]][2]);
  757.    printf("came from voxel atn");
  758.    printf("(%f, %f, %f)n", mesh->fromVoxels[i], 
  759.   mesh->fromVoxels[i+1], mesh->fromVoxels[i+2]);
  760.  }
  762. }
  765. // copy the part of the mesh that is in the clip box
  766. // into the newMeshSet (clipmesh)
  767. RigidScan*
  768. GenericScan::filtered_copy(const VertexFilter& filter)
  769. {
  770.   int i, j;
  771.   GenericScan* newMeshSet = new GenericScan;
  772.   assert(newMeshSet != NULL);
  773.   Mesh *newMesh, *oldMesh;
  775.   newMeshSet->setXform(getXform());
  777.   for (j = 0; j < meshes.size(); j++) {
  778.     vector<int> newIndices;
  779.     newMesh = new Mesh;
  780.     oldMesh = getMesh(j);
  782.     // figure out which vertices remain
  783.     int vertCount = 0;
  784.     for (i = 0; i < oldMesh->num_verts(); i++) {
  785.       if (filter.accept (oldMesh->vtx[i])) {
  786. newIndices.push_back(1);
  787. vertCount++;
  788.       } else {
  789. newIndices.push_back(-1);
  790.       }
  791.     }
  793.     // and then which faces remain
  794.     int triCount = 0;
  795.     for (i = 0; i < oldMesh->getTris().size(); i += 3) {
  796.       if (newIndices[oldMesh->tris[i  ]] >= 0 &&
  797.   newIndices[oldMesh->tris[i+1]] >= 0 &&
  798.   newIndices[oldMesh->tris[i+2]] >= 0) {
  799. triCount++;
  800.       }
  801.     }
  803.     // copy other mesh properties
  804.     newMesh->hasVertNormals = oldMesh->hasVertNormals;
  805.     if (oldMesh->vertMatDiff != NULL)
  806.       newMesh->vertMatDiff = new vec3uc[vertCount];
  807.     if (oldMesh->vertIntensity != NULL)
  808.       newMesh->vertIntensity = new float[vertCount];
  809.     if (oldMesh->vertConfidence != NULL)
  810.       newMesh->vertConfidence = new float[vertCount];
  811.     if (oldMesh->texture != NULL)
  812.       newMesh->texture = new vec2f[vertCount];
  813.     if (oldMesh->triMatDiff != NULL)
  814.       newMesh->triMatDiff = new vec3uc[triCount];
  816.     // copy the surviving vertices
  817.     int count = 0;
  818.     newMesh->vtx.reserve (vertCount);
  819.     if (oldMesh->nrm.size())
  820.       newMesh->nrm.reserve (vertCount);
  821.     for (i = 0; i < oldMesh->num_verts(); i++) {
  822.       if (newIndices[i] > 0) {
  823. newIndices[i] = count;
  824. newMesh->copyVertFrom (oldMesh, i, count);
  825. count++;
  826.       }
  827.     }
  829.     // copy and reindex the surviving faces
  830.     count = 0;
  831.     newMesh->tris.reserve (triCount * 3);
  832.     for (i = 0; i < oldMesh->tris.size(); i += 3) {
  833.       if (newIndices[oldMesh->tris[i  ]] >= 0 &&
  834.   newIndices[oldMesh->tris[i+1]] >= 0 &&
  835.   newIndices[oldMesh->tris[i+2]] >= 0) {
  837. newMesh->copyTriFrom (oldMesh, i/3, count/3);
  838. newMesh->tris[count  ] = newIndices[oldMesh->tris[i  ]];
  839. newMesh->tris[count+1] = newIndices[oldMesh->tris[i+1]];
  840. newMesh->tris[count+2] = newIndices[oldMesh->tris[i+2]];
  842. // copy fromVoxels info - for voxel display feature
  843. if (oldMesh->hasVoxels) {
  844.   newMesh->fromVoxels[count] = oldMesh->fromVoxels[i];
  845.   newMesh->fromVoxels[count+1] = oldMesh->fromVoxels[i+1];
  846.   newMesh->fromVoxels[count+2] = oldMesh->fromVoxels[i+2];
  847. }
  849. count += 3;
  850.       }
  851.     }
  853.     // and finalize this resolution
  854.     newMesh->bNeedsSave = true;
  855.     newMesh->computeBBox();
  857.     // and insert it into new GenericScan
  858.     crope clipName(get_basename());
  859.     char info[20];
  860.     sprintf (info, "Clip.%d.ply", triCount);
  861.     clipName += info;
  862.     newMeshSet->insertMesh (newMesh, clipName);
  863.   }
  865.   // done!
  866.   newMeshSet->computeBBox();
  867.   newMeshSet->curr_res = curr_res;
  868.   return newMeshSet;
  869. }
  872. bool
  873. GenericScan::filter_inplace(const VertexFilter &filter)
  874. {
  875.   for (int iRes = 0; iRes < resolutions.size(); iRes++) {
  876.     vector<int> newIndices;
  877.     Mesh* newMesh = new Mesh;
  878.     Mesh* oldMesh = getMesh(iRes);
  880.     // figure out which vertices remain
  881.     int vertCount = 0;
  882.     for (int i = 0; i < oldMesh->num_verts(); i++) {
  883.       if (filter.accept (oldMesh->vtx[i])) {
  884. newIndices.push_back(1);
  885. vertCount++;
  886.       } else {
  887. newIndices.push_back(-1);
  888.       }
  889.     }
  891.     // and then which faces remain
  892.     int triCount = 0;
  893.     for (i = 0; i < oldMesh->getTris().size(); i += 3) {
  894.       if (newIndices[oldMesh->tris[i  ]] >= 0 &&
  895.   newIndices[oldMesh->tris[i+1]] >= 0 &&
  896.   newIndices[oldMesh->tris[i+2]] >= 0) {
  897. triCount++;
  898.       }
  899.     }
  901.     // copy other mesh properties
  902.     newMesh->hasVertNormals = oldMesh->hasVertNormals;
  903.     if (oldMesh->vertMatDiff != NULL)
  904.       newMesh->vertMatDiff = new vec3uc[vertCount];
  905.     if (oldMesh->vertIntensity != NULL)
  906.       newMesh->vertIntensity = new float[vertCount];
  907.     if (oldMesh->vertConfidence != NULL)
  908.       newMesh->vertConfidence = new float[vertCount];
  909.     if (oldMesh->texture != NULL)
  910.       newMesh->texture = new vec2f[vertCount];
  911.     if (oldMesh->triMatDiff != NULL)
  912.       newMesh->triMatDiff = new vec3uc[triCount];
  914.     // copy the surviving vertices
  915.     int count = 0;
  916.     newMesh->vtx.reserve (vertCount);
  917.     if (oldMesh->nrm.size())
  918.       newMesh->nrm.reserve (vertCount);
  919.     for (i = 0; i < oldMesh->num_verts(); i++) {
  920.       if (newIndices[i] > 0) {
  921. newIndices[i] = count;
  922. newMesh->copyVertFrom (oldMesh, i, count);
  923. count++;
  924.       }
  925.     }
  927.     // copy and reindex the surviving faces
  928.     count = 0;
  929.     newMesh->tris.reserve (triCount * 3);
  930.     for (i = 0; i < oldMesh->tris.size(); i += 3) {
  931.       if (newIndices[oldMesh->tris[i  ]] >= 0 &&
  932.   newIndices[oldMesh->tris[i+1]] >= 0 &&
  933.   newIndices[oldMesh->tris[i+2]] >= 0) {
  934. // newIndices holds renumbered vertices
  935. newMesh->copyTriFrom (oldMesh, i/3, count/3);
  936. newMesh->tris[count  ] = newIndices[oldMesh->tris[i  ]];
  937. newMesh->tris[count+1] = newIndices[oldMesh->tris[i+1]];
  938. newMesh->tris[count+2] = newIndices[oldMesh->tris[i+2]];
  939. // copy from voxel info if we're supporting clipping later
  940. // for voxel display feature
  941. //if (oldMesh->hasVoxels) {
  942. //newMesh->fromVoxels[count] = oldMesh->fromVoxels[i];
  943. //newMesh->fromVoxels[count+1] = oldMesh->fromVoxels[i+1];
  944. //newMesh->fromVoxels[count+2] = oldMesh->fromVoxels[i+2];
  945. //}
  947. count += 3;
  948.       }
  949.     }
  951.     // and finalize this resolution
  952.     newMesh->bNeedsSave = true;
  953.     newMesh->computeBBox();
  955.     // and insert it in place of original
  956.     delete oldMesh;
  957.     meshes[iRes] = newMesh;
  958.     resolutions[iRes].abs_resolution = newMesh->num_tris();
  960.     // nuke any kdtree for this resolution
  961.     delete kdtree[iRes];
  962.     kdtree[iRes] = NULL;
  963.   }
  965.   // done!
  966.   computeBBox();
  967.   bDirty = true;
  968.   return true;
  969. }
  972. bool
  973. GenericScan::filter_vertices (const VertexFilter& filter, vector<Pnt3>& p)
  974. {
  975.   Mesh* mesh = currentMesh();
  977.   Pnt3* vtxend = mesh->vtx.end();
  978.   for (Pnt3* pnt = mesh->vtx.begin(); pnt < vtxend; pnt++) {
  979.     if (filter.accept (*pnt))
  980.       p.push_back (*pnt);
  981.   }
  983.   return true;
  984. }
  987. bool
  988. GenericScan::is_modified (void)
  989. {
  990.   return bDirty;
  991. }
  994. bool
  995. GenericScan::write_metadata (MetaData data)
  996. {
  997.   bool success = false;
  999.   pushd();   // don't return without matching popd!
  1001.   switch (data) {
  1002.   case md_xform: {
  1003.     success = TbObj::writeXform(get_basename());
  1004.     break;
  1005.   }
  1006.   }
  1008.   popd();
  1009.   return success;
  1010. }
  1013. bool 
  1014. GenericScan::write(const crope &fname)
  1015. {
  1016.   if (fname.empty()) {  // no filename given...
  1017.     if (!bNameSet)      // and we don't already have one
  1018.       return false;     // so bail
  1019.   } else if (name != fname) {
  1020.     cout << "Scan " << name << " being saved as " << fname << endl;
  1021.     
  1022.     // need to force all meshes to load before changing name
  1023.     for (int i = 0; i < resolutions.size(); i++) {
  1024.       load_resolution (i);
  1025.       meshes[i]->bNeedsSave = true;
  1026.     }
  1028.     set_name (fname);
  1029.     bNameSet = false;    // mark that we need to regenerate child names
  1030.   }
  1032.   if (ending == crope("set")) {
  1033.   } else {
  1034.     //need to generate .set name from current name
  1035.     const char* dirName = strrchr (name.c_str(), '/');
  1036.     if (dirName == NULL) {
  1037.       dirName = name.c_str();
  1038.     } else {
  1039.       dirName++; // skip past the /
  1040.     }
  1041.     name += crope("/") + crope(dirName);
  1043.     set_name (name + ".set");
  1044.     cout << "Creating new set file " << name << endl;
  1046.     setd (name, true);
  1047.   }
  1049.   cout << "Writing whole scan to " << name << endl;
  1050.   ofstream out (name.c_str());
  1052.   out << "NumMeshes = " << meshes.size() << endl;
  1053.   out << "DefaultRes = " << meshes[current_resolution_index()]->num_tris()
  1054.       << endl;
  1056.   pushd();
  1057.   for (int i = 0; i < meshes.size(); i++) {
  1058.     if (!bNameSet) {
  1059.       char stupidbuf[10];
  1060.       sprintf (stupidbuf, "%d", meshes[i]->num_tris());
  1062.       resolutions[i].filename = basename
  1063. + "." + stupidbuf + ".ply";
  1064.       // need to rename associated meshes
  1065.     }
  1067.     out << (resolutions[i].desired_in_mem ? "preload" : "noload") << " ";
  1068.     out << resolutions[i].abs_resolution << " ";
  1069.     out << resolutions[i].filename << endl;
  1071.     if (resolutions[i].in_memory && meshes[i]->bNeedsSave) {
  1072.       cout << "Writing mesh " << resolutions[i].filename << endl;
  1073.       meshes[i]->writePlyFile(resolutions[i].filename.c_str(), true, false);
  1074.     }
  1075.   }
  1076.   popd();
  1077.   cout << "Done." << endl;
  1079.   // save transform
  1080.   write_metadata (md_xform);
  1082.   bDirty = false;
  1083.   bNameSet = true;
  1084.   return true;
  1085. }
  1088. bool
  1089. GenericScan::write_resolution_mesh (int nPolys, const crope& fname,
  1090.     Xform<float> xfBy)
  1091. {
  1092.   if (!xfBy.isIdentity()) {
  1093.     // can't handle this any better than default implementation
  1094.     return RigidScan::write_resolution_mesh (nPolys, fname, xfBy);
  1095.   }
  1097.   int iRes = findLevelForRes (nPolys);
  1098.   if (iRes < 0 || iRes >= resolutions.size())
  1099.     return false;
  1101.   crope& meshName = resolutions[iRes].filename;
  1102.   if (!fname.empty())
  1103.     meshName = fname;
  1105.   if (meshName.empty())
  1106.     return false;
  1108.   cout << "Writing plyfile " << meshName << "... "<< flush;
  1109.   bool ok = getMesh(iRes)->writePlyFile (meshName.c_str(), false, false);
  1110.   if (ok)
  1111.     cout << "done." << endl;
  1112.   else
  1113.     cout << "failed!" << endl;
  1115.   return ok;
  1116. }
  1119. int 
  1120. PlvWritePlyForVripCmd(ClientData clientData, 
  1121.       Tcl_Interp *interp,
  1122.       int argc, char* argv[])
  1123. {
  1124.   if (argc < 3) {
  1125.       interp->result = 
  1126. "Usage: PlvWritePlyForVripCmd <res level, 0=max> <dir> ";
  1127.       return TCL_ERROR;
  1128.   }
  1130.   int iRes = atoi (argv[1]);
  1131.   char* dir = argv[2];
  1132.   portable_mkdir (dir, 00775);
  1134.   char name[PATH_MAX];
  1135.   crope result;
  1136.   bool success = true;
  1138.   // vrip can't read tstrips
  1139.   char* oldStripVal = Tcl_GetVar (interp, "meshWriteStrips", 
  1140.   TCL_GLOBAL_ONLY);
  1141.   Tcl_SetVar (interp, "meshWriteStrips", "never", 
  1142.       TCL_GLOBAL_ONLY);
  1144.   char confFN[PATH_MAX];
  1145.   sprintf (confFN, "%s/vrip.conf", dir);
  1146.   ofstream conffile (confFN, ios::app);
  1148.   DisplayableMesh** dm = theScene->meshSets.begin();
  1149.   for (; dm < theScene->meshSets.end(); dm++) {
  1150.     if (!(*dm)->getVisible())
  1151.       continue;
  1153.     RigidScan* sd = (*dm)->getMeshData();
  1154.     GenericScan* gs = dynamic_cast<GenericScan*> (sd);
  1155.     if (!gs)
  1156.       continue;
  1158.     vector<ResolutionCtrl::res_info> ri;
  1159.     int thisIRes;
  1161.     const char* filename = sd->get_basename().c_str();
  1162.     const char* slash;
  1163.     if (NULL != (slash = strrchr (filename, '/')))
  1164.       filename = slash + 1;
  1165.     else if (NULL != (slash = strrchr (filename, '\')))
  1166.       filename = slash + 1;
  1168.     sprintf(name, "%s/%s-v.ply", dir, filename);
  1170.     if (access (name, R_OK)) {
  1171.   cout << "Writing " << name << " ... " << flush;
  1172.     } else {
  1173.   cout << "Skipping " << name << " (already exists) ... " << endl;
  1174.   continue;
  1175.     }
  1177.     sd->existing_resolutions (ri);
  1178.     thisIRes = MIN (iRes, ri.size() - 1);
  1179.     gs->load_resolution (thisIRes);
  1181.     sd->existing_resolutions (ri);
  1182.     int res = ri[thisIRes].abs_resolution;
  1184.     if (res) {
  1185.   
  1186.   // write plyfile
  1187.   if (!gs->write_resolution_mesh (res, name, Xform<float>())) {
  1188.     cerr << "Scan " << sd->get_name() 
  1189.  << " failed to write self!"  << endl;
  1190.     return TCL_ERROR;
  1191.   }
  1192.   
  1193.   cout << "done." << endl;
  1194.   
  1195.   // write config string:
  1196.   // bmesh filename x y z i j k r
  1197.   char bmesh[PATH_MAX + 200];
  1198.   float t[3];
  1199.   float q[4];
  1200.   Xform<float> xf = sd->getXform();
  1201.   xf.toQuaternion (q);
  1202.   xf.getTranslation (t);
  1203.   sprintf (bmesh, "bmesh %s %g %g %g %g %g %g %g", 
  1204.    1+strrchr(name,'/'),
  1205.    t[0], t[1], t[2], -q[1], -q[2], -q[3], q[0]);
  1206.   
  1207.   // write xf
  1208.   strcpy (name + strlen(name) - 3, "xf");
  1209.   cout << "Writing " << name << " ... " << flush;
  1210.   ofstream xffile (name);
  1211.   xffile << xf;
  1212.   if (xffile.fail()) {
  1213.     cerr << "Scan " << sd->get_name() 
  1214.  << " failed to write xform!" << endl;
  1215.     success = false;
  1216.     break;
  1217.   }
  1218.   cout << "done." << endl;
  1220.   conffile << bmesh << endl;
  1222.     }
  1224.   }
  1225.   
  1226.   // cleanup
  1227.   Tcl_SetVar (interp, "meshWriteStrips", oldStripVal, 
  1228.       TCL_GLOBAL_ONLY);
  1230.   if (!success)
  1231.     return TCL_ERROR;
  1233.   return TCL_OK;
  1234. }
  1236. void GenericScan::dequantizationSmoothing(int iterations, double maxDisplacement)
  1237. {
  1238.   Mesh *mesh=currentMesh();
  1240.   // Get the original verts into both lists
  1241.   mesh->restoreOrigVerts();
  1243.   for (int i=0;i<iterations;i++)
  1244.     mesh->dequantizationSmoothing(maxDisplacement);
  1245. }
  1247. void GenericScan::commitSmoothingChanges()
  1248. {
  1249.   Mesh *mesh=currentMesh();
  1251.   // Copy the vtx -> orig_vtx, so the real orig is gone
  1252.   mesh->saveOrigVerts();
  1253. }