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

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

3D图形编程

开发平台：

Visual C++

Mesh.cc：源码内容
  1. #include <iostream.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <limits.h>
  5. #include <vector.h>
  6. #include <hash_map.h>
  7. #include <assert.h>
  8. #include <math.h>
  10. #include "Mesh.h"
  11. #include "ply++.h"
  12. #include "Timer.h"
  13. #include "Random.h"
  14. #include "plvGlobals.h"
  15. #include "TriMeshUtils.h"
  16. #include "Progress.h"
  17. #include "plvScene.h"
  20. #if 0
  21. #  define VERBOSE 1
  22. #else
  23. #  define VERBOSE 0
  24. #endif
  27. Mesh::Mesh()
  28. {
  29.   init();
  30. }
  32. Mesh::Mesh (const vector<Pnt3>& _vtx, const vector<int>& _tris)
  33. {
  34.   init();
  35.   vtx = _vtx;
  36.   tris = _tris;
  37.   
  38.   initNormals(UseAreaWeightedNormals);
  39.   computeBBox();
  40. }
  43. void Mesh::init()
  44. {
  45.   vertMatDiff = NULL;
  46.   vertIntensity = NULL;
  47.   vertConfidence = NULL;
  48.   texture = NULL;
  49.   triMatDiff = NULL;
  50.   hasVertNormals = FALSE;
  51.   bNeedsSave = FALSE;
  52.   numTris = 0;
  53.   hasVoxels = FALSE;
  54. }
  57. Mesh::~Mesh()
  58. {
  59.   if (vertMatDiff != NULL)
  60.     delete [] vertMatDiff;
  61.   
  62.   if (vertIntensity != NULL)
  63.     delete [] vertIntensity;
  64.   
  65.   if (vertConfidence != NULL)
  66.     delete [] vertConfidence;
  67.   
  68.   if (texture != NULL)
  69.     delete [] texture;
  70.   
  71.   if (triMatDiff != NULL)
  72.     delete [] triMatDiff;
  73. }
  76. void
  77. Mesh::initNormals(int useArea)
  78. {
  79.   if (!hasVertNormals) {
  80.     if (tstrips.size())
  81.       getVertexNormals(vtx, tstrips, true, nrm, useArea);
  82.     else
  83.       getVertexNormals(vtx, tris, false, nrm, useArea);
  84.     hasVertNormals = true;
  85.   }
  86. }
  88. void 
  89. Mesh::flipNormals()
  90. {
  91.   if (tris.size())
  92.     flip_tris (tris, false);
  94.   if (tstrips.size())
  95.     flip_tris (tstrips, true);
  97.   int n = nrm.size();
  98.   for (int i = 0; i < n; i++)
  99.     nrm[i] = -nrm[i];
  101.   bNeedsSave = TRUE;
  102. }
  105. void
  106. Mesh::computeBBox()
  107. {
  108.   bbox.clear();
  110.   for (int i = 0; i < vtx.size(); i++) {
  111.     bbox.add(vtx[i]);
  112.   }
  114.   if (vtx.size() == 0) {
  115.     center = Pnt3();
  116.     radius = 0;
  117.   } else {
  118.     center = bbox.center();
  119.     radius = bbox.diag()*.5;
  120.   }
  121. }
  124. void
  125. Mesh::updateScale()
  126.   // this exists because Mesh is only used to read .ply files, and
  127.   // there's a lot of old legacy data that exists in meters instead
  128.   // of millimeters.  Not only will it display at the wrong scale
  129.   // (only a problem if you view it side-by-side with new data),
  130.   // but things that are typical sizes for a scan with the older
  131.   // CyberWare scanners, like the dragon (say 20 cm across), expressed in
  132.   // meters, will have dimensions on the scale of 0.01.  Inter-point
  133.   // spacing will be like .0001, and so cross products at triangle
  134.   // vertices will have norms below float thresholds.  Thus the normals
  135.   // used for lighting will be calculated incorrectly.  Unfortunately the
  136.   // headers of these files don't say whether they're measured in meters
  137.   // or millimeters.  So we'll try to guess from the size of the bbox.
  138. {
  139.   // if the largest dimension is smaller than 10, assume we're dealing
  140.   // with millimeters and scale everything up by 1000.
  142.   // will false-positive on millimeter-scale scans of objects smaller than 
  143.   // 1cm x 1cm x 1cm (and they'll look too big).
  145.   // will false-negative on meter-scale scans of objects bigger than 10m
  146.   // on any side (and they'll stay too small, and render black).
  148.   // will not affect ply conversions of Cyra data, whose dimensions are
  149.   // big enough to be in the bounds of the above test, because the test is 
  150.   // one-way, only growing things -- although if Cyra data were mistakenly 
  151.   // saved as meters, this test would probably not catch it (the false
  152.   // negative described above).
  154.   // But wait!  This hack sucks rocks for pvrip output.  Often
  155.   // you get one or two chunks that are too small, so they scale
  156.   // by 1000, and suddenly the viewing bbox is 1000x too big,
  157.   // and everything else is 1000x too small (in comparison) and
  158.   // so you only see that tiny chunk (or nothing at all) when
  159.   // the viewer pops up.  You have to find and delete the scan
  160.   // that got multiplied before you can rescale the viewer to
  161.   // be able to see the rest of the mesh. UGLY Hack.  Turning
  162.   // it off, legacy crud be damned.  -- Lucas
  164.   computeBBox();
  165. #if 0
  166.   if (bbox.maxDim() < 10) {
  167.     cerr << "Warning: scaling mesh from meters to millimeters" << endl;
  168.     for (Pnt3* vp = vtx.begin(); vp != vtx.end(); vp++) {
  169.       *vp *= 1000;
  170.     }
  172.     computeBBox();
  173.   }
  174. #endif
  175. }
  178. int
  179. Mesh::num_tris (void)
  180. {
  181.   if (tris.size())
  182.     return (numTris = tris.size() / 3);
  184.   if (numTris)
  185.     return numTris;
  187.   // ok, have to count tstrips
  188.   numTris = tstrips.size();
  189.   for (const int* ti = tstrips.begin(); ti < tstrips.end(); ti++) {
  190.     if ((*ti) == -1)
  191.       numTris -= 3;
  192.   }
  194.   return numTris;
  195. }
  197. vector<int>&
  198. Mesh::getTris (void)
  199. {
  200.   if (!tris.size()) {
  201.     strips_to_tris(tstrips, tris, numTris);
  202.     printf ("rehydrated %d trisn", num_tris());
  203.   }
  205.   return tris;
  206. }
  209. vector<int>&
  210. Mesh::getTstrips (void)
  211. {
  212.   if (!tstrips.size()) {
  213. #if VERBOSE
  214.     TIMER(Build_t_strips);
  215. #endif
  216.     tris_to_strips(vtx.size(), tris, tstrips);
  217.   }
  219.   return tstrips;
  220. }
  223. void
  224. Mesh::freeTris (void)
  225. {
  226.   if (tstrips.size() == 0)
  227.     printf ("Cannot free triangles because strips don't existn");
  228.   else {
  229.     tris.clear();
  230.     delete [] triMatDiff;
  231.     triMatDiff = NULL;
  232.   }
  233. }
  236. void
  237. Mesh::freeTStrips (void)
  238. {
  239.   if (tris.size() == 0)
  240.     printf ("Cannot free tstrips because separate triangles don't existn");
  241.   else {
  242.     tstrips.clear();
  243.   }
  244. }
  247. // src and dst are indices to the triangle face (i.e., vertex face / 3).
  249. void
  250. Mesh::copyTriFrom (Mesh *meshSrc, int src, int dst)
  251. {
  252.   if (meshSrc->hasVoxels) this->hasVoxels = true;
  253.   for (int i = 0; i < 3; i++) {
  254.     // make sure triangle is within bounds of vector
  255.     assert(3*dst+i <= this->tris.size());
  257.     if (3*dst+i < this->tris.size()) {
  258.       this->tris[3*dst+i] = meshSrc->tris[3*src+i];
  259.       // copy voxel in - for voxel display feature
  260.       if (meshSrc->hasVoxels) 
  261. this->fromVoxels[3*dst+i] = meshSrc->fromVoxels[3*src+i];
  262.       
  263.     } else {  // adding to the end
  264.       this->tris.push_back (meshSrc->tris[3*src+i]);
  265.       if (meshSrc->hasVoxels) 
  266. this->fromVoxels.push_back(meshSrc->fromVoxels[3*src+i]);
  267.       
  268.     }
  269.   }
  270.     
  271.   if (meshSrc->triMatDiff != NULL) {
  272.     this->triMatDiff[dst][0] = meshSrc->triMatDiff[src][0];
  273.     this->triMatDiff[dst][1] = meshSrc->triMatDiff[src][1];
  274.     this->triMatDiff[dst][2] = meshSrc->triMatDiff[src][2];
  275.   }
  276. }
  279. void
  280. Mesh::copyVertFrom (Mesh *meshSrc, int src, int dst)
  281. {
  282.   assert (dst <= this->vtx.size());
  283.   if (dst < this->vtx.size())
  284.     this->vtx[dst] = meshSrc->vtx[src];
  285.   else
  286.     this->vtx.push_back(meshSrc->vtx[src]);
  288.   if (this->nrm.capacity() && meshSrc->nrm.size()) {
  289.     int nd = 3 * dst;
  290.     int ns = 3 * src;
  291.     if (nd < this->nrm.size()) {
  292.       this->nrm[nd  ] = meshSrc->nrm[ns  ];
  293.       this->nrm[nd+1] = meshSrc->nrm[ns+1];
  294.       this->nrm[nd+2] = meshSrc->nrm[ns+2];
  295.     } else {
  296.       this->nrm.push_back(meshSrc->nrm[ns  ]);
  297.       this->nrm.push_back(meshSrc->nrm[ns+1]);
  298.       this->nrm.push_back(meshSrc->nrm[ns+2]);
  299.     }
  300.   }
  301.   
  302.   if (meshSrc->vertMatDiff != NULL) {
  303.     this->vertMatDiff[dst][0] = meshSrc->vertMatDiff[src][0];
  304.     this->vertMatDiff[dst][1] = meshSrc->vertMatDiff[src][1];
  305.     this->vertMatDiff[dst][2] = meshSrc->vertMatDiff[src][2];
  306.   }
  307.   
  308.   if (meshSrc->vertIntensity != NULL) {
  309.     this->vertIntensity[dst] = meshSrc->vertIntensity[src];
  310.   }
  311.   
  312.   if (meshSrc->vertConfidence != NULL) {
  313.     this->vertConfidence[dst] = meshSrc->vertConfidence[src];
  314.   }
  315.   
  316.   if (meshSrc->texture != NULL) {
  317.     this->texture[dst][0] = meshSrc->texture[src][0];
  318.     this->texture[dst][1] = meshSrc->texture[src][1];
  319.   }
  320. }
  325. void
  326. Mesh::mark_boundary_verts(void)
  327. {
  328.   if (bdry.size()) return;
  329.   // initialize the boundary flags
  330.   //bdry.erase(bdry.begin(), bdry.end());
  331.   bdry.insert(bdry.end(), vtx.size(), 0);
  332.   ::mark_boundary_verts(bdry, getTris());
  333. }
  336. void plycrunch_simplify (const vector<Pnt3>& vtx, const vector<int>& tris,
  337.  vector<Pnt3>& outVtx, vector<int>& outTris,
  338.  int approxDesired);
  340. Mesh *
  341. Mesh::Decimate(int numFaces, int optLevel,
  342.        float errLevel, float boundWeight,
  343.        ResolutionCtrl::Decimator dec)
  344. {
  345.   Mesh  *outMesh = new Mesh();
  347.   switch (dec) {
  348.   case ResolutionCtrl::decQslim:
  349.     quadric_simplify(vtx, getTris(), outMesh->vtx, outMesh->tris,
  350.      numFaces, optLevel, errLevel, boundWeight);
  351.     break;
  353.   case ResolutionCtrl::decPlycrunch:
  354.     plycrunch_simplify (vtx, getTris(), outMesh->vtx, outMesh->tris, numFaces);
  355.     break;
  357.   default:
  358.     cerr << "Mesh::Decimate: unsupported decimator " << dec << endl;
  359.     delete outMesh;
  360.     return NULL;
  361.   }
  363.   outMesh->initNormals(0);
  364.   outMesh->computeBBox();
  366.   return outMesh;
  367. }
  369. struct PlyVertex {
  370.   float x, y, z;
  371.   float nx, ny, nz;
  372.   uchar diff_r, diff_g, diff_b;
  373.   float tex_u, tex_v;
  374.   float intensity;
  375.   float std_dev;
  376.   float confidence;
  377. };
  379. const int MAX_FACE_VERTS = 100;
  381. /* Added field to hold voxel from which the face was derived 
  382.    - for voxel display feature */
  383. struct PlyFace {
  384.   uchar nverts;
  385.   int verts[MAX_FACE_VERTS];
  386.   float fromVoxelX, fromVoxelY, fromVoxelZ;
  387. };
  390. struct CoordConfVert {
  391.    float v[3];
  392.    float conf;
  393. };
  395. struct TriLocal {
  396.    uchar nverts;
  397.    int index[3];
  398. };
  401. static PlyProperty vert_prop_x =  
  402.    {"x", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  403. static PlyProperty vert_prop_y =  
  404.   {"y", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  405. static PlyProperty vert_prop_z =  
  406.   {"z", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  407. static PlyProperty vert_prop_nx =  
  408.    {"nx", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  409. static PlyProperty vert_prop_ny =  
  410.   {"ny", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  411. static PlyProperty vert_prop_nz =  
  412.   {"nz", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  413. static PlyProperty vert_prop_texture_u =  
  414.   {"texture_u", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  415. static PlyProperty vert_prop_texture_v =  
  416.   {"texture_v", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  417. static PlyProperty vert_prop_intens =  
  418.   {"intensity", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  419. static PlyProperty vert_prop_std_dev =  
  420.   {"std_dev", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  421. static PlyProperty vert_prop_confidence =  
  422.   {"confidence", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  423. static PlyProperty vert_prop_diff_r =  
  424.   {"diffuse_red", PLY_UCHAR, PLY_UCHAR, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  425. static PlyProperty vert_prop_diff_g =  
  426.   {"diffuse_green", PLY_UCHAR, PLY_UCHAR, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  427. static PlyProperty vert_prop_diff_b =  
  428.   {"diffuse_blue", PLY_UCHAR, PLY_UCHAR, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  430. /* Added another face_prop that holds data for the voxel from which
  431.    the face was derived - for voxel display feature */
  432. static PlyProperty face_props[] = { 
  433.   {"vertex_indices", PLY_INT, PLY_INT, 0, 1, PLY_UCHAR, PLY_UCHAR, 0},
  434. };
  436. static PlyProperty face_prop_from_voxel_x =
  437.   {"from_voxel_x", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  438. static PlyProperty face_prop_from_voxel_y =
  439.   {"from_voxel_y", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  440. static PlyProperty face_prop_from_voxel_z =
  441.   {"from_voxel_z", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  444. struct tstrip_info {
  445.   int nverts;
  446.   int* vertData;
  447. };
  449. static PlyProperty tstrips_props[] = {
  450.   {"vertex_indices", PLY_INT, PLY_INT, 4, 1, PLY_INT, PLY_INT, 0},
  451. };
  453. static void
  454. set_offsets(void)
  455. {
  456.   static int first = 1;
  457.   if (first) {
  458.     first = 0;
  459.     vert_prop_x.offset          = offsetof(PlyVertex,x);
  460.     vert_prop_y.offset          = offsetof(PlyVertex,y);
  461.     vert_prop_z.offset          = offsetof(PlyVertex,z);
  462.     vert_prop_nx.offset         = offsetof(PlyVertex,nx);
  463.     vert_prop_ny.offset         = offsetof(PlyVertex,ny);
  464.     vert_prop_nz.offset         = offsetof(PlyVertex,nz);
  465.     vert_prop_intens.offset     = offsetof(PlyVertex, intensity);
  466.     vert_prop_std_dev.offset    = offsetof(PlyVertex, std_dev);
  467.     vert_prop_confidence.offset = offsetof(PlyVertex, confidence);
  468.     vert_prop_diff_r.offset     = offsetof(PlyVertex,diff_r);
  469.     vert_prop_diff_g.offset     = offsetof(PlyVertex,diff_g);
  470.     vert_prop_diff_b.offset     = offsetof(PlyVertex,diff_b);
  471.     vert_prop_texture_u.offset  = offsetof(PlyVertex,tex_u);
  472.     vert_prop_texture_v.offset  = offsetof(PlyVertex,tex_v);
  474.     tstrips_props[0].offset     = offsetof(tstrip_info,vertData);
  475.   }
  476. }
  478. static const int progress_update = 0xfff;
  480. int  
  481. Mesh::readPlyFile(const char *filename)
  482. {
  483.   int i, j;
  484.   int nelems;
  485.   char **elist;
  486.   char **obj_info;
  487.   int num_obj_info;
  488.   char *elem_name;
  489.   int nprops;
  490.   int num_elems;
  491.   int hasConfidence = 0;
  492.   //int hasIntensity = 0;
  493.   //int hasStdDev = 0;
  494.   int hasDiffuseColors = 0;
  495.   int hasTexture = 0;
  496.   int notATriangleMesh = 0;
  497.   int skipTexture = 1;
  499. #if VERBOSE
  500.   TIMER(Read_ply_file);
  501. #endif
  503.   face_props[0].offset = offsetof(PlyFace, verts);
  504.   face_props[0].count_offset = offsetof(PlyFace, nverts);
  506.   // face_prop offsets for voxel display feature
  507.   face_prop_from_voxel_x.offset = offsetof(PlyFace, fromVoxelX);
  508.   face_prop_from_voxel_y.offset = offsetof(PlyFace, fromVoxelY);
  509.   face_prop_from_voxel_z.offset = offsetof(PlyFace, fromVoxelZ);
  510.     
  511.   PlyFile ply;
  512.   if (ply.open_for_reading((char*)filename, &nelems, &elist) == 0)
  513.     return 0;
  515.   // Look for a texture file reference
  516.   char temp[PATH_MAX];
  517.   obj_info = ply.get_obj_info (&num_obj_info);
  518.   for (i = 0; i < num_obj_info; i++) {
  519.     if (strstr(obj_info[i], "texture_file")) {
  520.       sscanf(obj_info[i], "%s%s", temp, texFileName);
  521.       FILE *fp = fopen(texFileName, "r");
  522.       if (fp != NULL) {
  523. fclose(fp);
  524. skipTexture = 0;
  525.       } else {
  526. texFileName[0] = 0;
  527.       }
  528.     }
  529.   }
  530.    
  531.   vector<PlyProperty> vert_props;
  533.   set_offsets();
  535.   PlyVertex plyVert;
  536.   PlyFace plyFace;
  538.   for (i = 0; i < nelems; i++) {
  540.     // get the description of the first element
  541.     elem_name = elist[i];
  542.     ply.get_element_description(elem_name, &num_elems, &nprops);
  544.     // if we're on vertex elements, read them in
  545.     if (equal_strings ("vertex", elem_name)) {
  546.    
  547. #if VERBOSE 
  548.       TIMER(Read_vertices);
  549. #endif
  551.       vtx.reserve(num_elems);
  552.     
  553.       if (ply.is_valid_property("vertex", vert_prop_x.name) &&
  554.   ply.is_valid_property("vertex", vert_prop_y.name) &&
  555.   ply.is_valid_property("vertex", vert_prop_z.name)) {
  556. ply.get_property(elem_name, &vert_prop_x);
  557. ply.get_property(elem_name, &vert_prop_y);
  558. ply.get_property(elem_name, &vert_prop_z);
  559.       }
  560.   
  561.       if (ply.is_valid_property("vertex", vert_prop_nx.name) &&
  562.   ply.is_valid_property("vertex", vert_prop_ny.name) &&
  563.   ply.is_valid_property("vertex", vert_prop_nz.name) ) {
  564. ply.get_property(elem_name, &vert_prop_nx);
  565. ply.get_property(elem_name, &vert_prop_ny);
  566. ply.get_property(elem_name, &vert_prop_nz);
  567. hasVertNormals = 1;
  568. nrm.reserve(num_elems * 3);
  569.       }
  570.   
  571.       if (ply.is_valid_property("vertex", vert_prop_intens.name)) {
  572. ply.get_property(elem_name, &vert_prop_intens);
  573. //hasIntensity = 1;
  574.       }
  575.     
  576.       if (ply.is_valid_property("vertex", vert_prop_std_dev.name)){
  577. ply.get_property(elem_name, &vert_prop_std_dev);
  578. //hasStdDev = 1;
  579.       }
  580.     
  581.       if (ply.is_valid_property("vertex", 
  582. vert_prop_confidence.name)) {
  583. ply.get_property(elem_name, &vert_prop_confidence);
  584. hasConfidence = 1;
  585. vertConfidence = new float[num_elems];
  586.       }
  587.     
  588.       if (ply.is_valid_property("vertex", "diffuse_red") &&
  589.   ply.is_valid_property("vertex", "diffuse_green") &&
  590.   ply.is_valid_property("vertex", "diffuse_blue")) {
  591. ply.get_property(elem_name, &vert_prop_diff_r);
  592. ply.get_property(elem_name, &vert_prop_diff_g);
  593. ply.get_property(elem_name, &vert_prop_diff_b);
  594. hasDiffuseColors = 1;
  595. vertMatDiff = new vec3uc[num_elems];
  596.       }
  597.     
  598.       if (!skipTexture) {
  599. if (ply.is_valid_property("vertex", "texture_u") &&
  600.     ply.is_valid_property("vertex", "texture_v")) {
  601.   ply.get_property(elem_name, &vert_prop_texture_u);
  602.   ply.get_property(elem_name, &vert_prop_texture_v);
  603.   hasTexture = 1;
  604.   texture = new vec2f[num_elems];
  605. }
  606.       }
  608.       Progress progress (num_elems, "%s: read vertices", filename);
  610.       // grab all the vertex elements
  611.       for (j = 0; j < num_elems; j++) {
  612. if ((j & progress_update) == progress_update)
  613.   progress.update (j);
  615. ply.get_element ((void *) &plyVert);
  616. vtx.push_back(Pnt3(plyVert.x, plyVert.y, plyVert.z));
  618. if (hasVertNormals)
  619.   pushNormalAsShorts (nrm, Pnt3(plyVert.nx, plyVert.ny, plyVert.nz));
  621. if (hasDiffuseColors) {
  622.   vertMatDiff[j][0] = plyVert.diff_r;
  623.   vertMatDiff[j][1] = plyVert.diff_g;
  624.   vertMatDiff[j][2] = plyVert.diff_b;
  625. }
  627. if (hasConfidence) {
  628.   vertConfidence[j] = plyVert.confidence;
  629. }
  631. if (hasTexture) {
  632.   texture[j][0] = plyVert.tex_u;
  633.   texture[j][1] = plyVert.tex_v;
  634. }
  635.       }
  636.     }
  638.     if (equal_strings ("face", elem_name)) {
  640. #if VERBOSE
  641.       TIMER(Read_faces);
  642. #endif
  644.       ply.get_property(elem_name, face_props);
  646.       /* check to see if we have voxel information for voxel
  647.          display feature */
  648.       if (ply.is_valid_property("face", "from_voxel_x")
  649.   || ply.is_valid_property("face", "from_voxel_y")
  650.   || ply.is_valid_property("face", "from_voxel_z")) {
  651. printf("Voxel information present...n");
  652. ply.get_property(elem_name, &face_prop_from_voxel_x);
  653. ply.get_property(elem_name, &face_prop_from_voxel_y);
  654. ply.get_property(elem_name, &face_prop_from_voxel_z);
  655. hasVoxels = 1;
  656.       } else printf("No voxel information stored...n");
  657.       
  658.       if (num_elems == 0)
  659. continue;
  661.       assert(tris.size() == 0);
  662.       tris.reserve (num_elems * 3);
  663.       Progress progress (num_elems, "%s: read tris", filename);
  665.       for (j = 0; j < num_elems; j++) {
  666. if ((j & progress_update) == progress_update)
  667.   progress.update (j);
  669. ply.get_element_noalloc((void *) &plyFace);
  670. if (plyFace.nverts != 3)
  671.   notATriangleMesh = 1;
  672. assert(plyFace.nverts <= MAX_FACE_VERTS);
  673. addTri(plyFace.verts[0],
  674.        plyFace.verts[1],
  675.        plyFace.verts[2]);
  676. if (hasVoxels) {
  677.   /* printf("adding voxel %f, %f, %fn",
  678.  plyFace.fromVoxelX, plyFace.fromVoxelY,
  679.  plyFace.fromVoxelZ); */
  680.   /* store voxel here - for voxel display feature */
  681.   
  682.   addVoxelInfo(plyFace.verts[0], plyFace.verts[1],
  683.        plyFace.verts[2],
  684.        plyFace.fromVoxelX, plyFace.fromVoxelY,
  685.        plyFace.fromVoxelZ);
  686. }
  688. //delete[] plyFace.verts;
  689.       }
  691.       if (notATriangleMesh) {
  692. cerr << "readPlyFile: Not a triangle mesh!" << endl;
  693.       }
  694.     }
  696.     if (equal_strings ("tristrips", elem_name)) {
  698.       tstrip_info info;
  700.       if (num_elems != 1)
  701. continue;
  703. #if VERBOSE
  704.       TIMER(Read_stripped_faces);
  705. #endif
  707.       ply.get_property (elem_name, tstrips_props);
  708.       ply.get_element ((void*)&info);
  709.       tstrips.reserve (info.nverts);
  710.       Progress progress (info.nverts, "%s: read t-strips", filename);
  712.       int lastend = 0;
  713.       for (int iv = 0; iv < info.nverts; iv++) {
  714. if ((iv & progress_update) == progress_update)
  715.   progress.update (iv);
  717. int vert = info.vertData[iv];
  718. bool ok = (vert >= 0 && vert < vtx.size())
  719.   || (vert == -1 && lastend >= 3);
  721. if (ok) {
  722.   // middle of strip
  723.   tstrips.push_back (vert);
  724.   if (vert == -1)
  725.     lastend = 0;
  726.   else
  727.     ++lastend;
  728. } else {
  729.   cerr << "nnRed alert: invalid index " << vert
  730.        << " in tstrip (index = " << iv
  731.        << ", valid range=0.." << vtx.size() - 1
  732.        << ")n" << endl;
  733.   // remove last strip
  734.   if (lastend) {
  735.     while (--lastend)
  736.       tstrips.pop_back();
  737.   }
  738. }
  739.       }
  740.     }
  741.   }
  743.   return 1;
  744. }
  746. int
  747. Mesh::writePlyFile (const char *filename, int useColorNotTexture, 
  748.     int writeNormals)
  749. {
  750. #if 1
  751.   vector<int>* pInds = NULL;
  752.   bool bStrips = false;
  753.   vector<uchar> color;
  754.   vector<float> conf;
  756.   if (theScene->meshes_written_stripped()) {
  757.     pInds = &getTstrips();
  758.     bStrips = true;
  759.   } else {
  760.     pInds = &getTris();
  761.     bStrips = false;
  762.   }
  764.   if (vertMatDiff) {
  765.     color.reserve (vtx.size() * 3);
  766.     for (int i = 0; i < vtx.size(); i++) {
  767.       color.push_back (vertMatDiff[i][0]);
  768.       color.push_back (vertMatDiff[i][1]);
  769.       color.push_back (vertMatDiff[i][2]);
  770.     }
  771.   } else if (vertIntensity) {
  772.     color.reserve (vtx.size());
  773.     for (int i = 0; i < vtx.size(); i++)
  774.       color.push_back (vertIntensity[i]);
  775.   }
  777.   if (vertConfidence) {
  778.     conf.reserve (vtx.size());
  779.     for (int i = 0; i < vtx.size(); i++)
  780.       conf.push_back (vertConfidence[i]);
  781.   }
  783.   if (color.size())
  784.     if (conf.size())
  785.       write_ply_file (filename, vtx, *pInds, bStrips, color, conf);
  786.     else
  787.       write_ply_file (filename, vtx, *pInds, bStrips, color);
  788.   else
  789.     if (conf.size())
  790.       write_ply_file (filename, vtx, *pInds, bStrips, conf);
  791.     else
  792.       write_ply_file (filename, vtx, *pInds, bStrips);
  794.   return true;
  795. #else
  796.   int i;
  797.   char *elem_names[] = {"vertex", "face"};
  799.   int hasIntensity  = vertIntensity != NULL;
  800.   int hasColor      = vertMatDiff != NULL;
  801.   int hasConfidence = vertConfidence != NULL;
  802.   int hasTexture    = texture != NULL;
  804.   PlyFile ply;
  805.   if (!ply.open_for_writing((char*)filename, 2, elem_names,PLY_BINARY_BE))
  806.     return 0;
  808.   if (hasTexture && !useColorNotTexture) {
  809.     char obj_info[PATH_MAX];
  810.     sprintf(obj_info, "%s %s", "texture_file", texFileName);
  811.     ply.put_obj_info(obj_info);
  812.   }
  814.   vector<PlyProperty> vert_props;
  815.   set_offsets();
  817.   vert_props.push_back(vert_prop_x);
  818.   vert_props.push_back(vert_prop_y);
  819.   vert_props.push_back(vert_prop_z);
  821.   if (writeNormals) {
  822.     vert_props.push_back(vert_prop_nx);
  823.     vert_props.push_back(vert_prop_ny);
  824.     vert_props.push_back(vert_prop_nz);
  825.   }
  827.   if (hasIntensity) {
  828.     vert_props.push_back(vert_prop_intens);
  829.   }
  830.     
  831.   if (hasConfidence) {
  832.     vert_props.push_back(vert_prop_confidence);
  833.     hasConfidence = 1;
  834.   }
  835.     
  836.   if (hasColor || (hasTexture && useColorNotTexture)) {
  837.     vert_props.push_back(vert_prop_diff_r);
  838.     vert_props.push_back(vert_prop_diff_g);
  839.     vert_props.push_back(vert_prop_diff_b);
  840.   }
  841.     
  842.   if (hasTexture && !useColorNotTexture) {
  843.     vert_props.push_back(vert_prop_texture_u);
  844.     vert_props.push_back(vert_prop_texture_v);
  845.   }
  847.   // count offset
  848.   face_props[0].offset = offsetof(PlyFace, verts);
  849.   face_props[0].count_offset = offsetof(PlyFace, nverts);
  850.   
  851.   ply.describe_element("vertex", vtx.size(), 
  852.        vert_props.size(), &vert_props[0]);
  853.   ply.describe_element("face", tris.size()/3, 1, face_props);
  854.   ply.header_complete();
  855.     
  856.     // set up and write the vertex elements
  857.   PlyVertex plyVert;
  859.   ply.put_element_setup("vertex");
  861.   for (i = 0; i < vtx.size(); i++) {
  862.     plyVert.x = vtx[i][0];
  863.     plyVert.y = vtx[i][1];
  864.     plyVert.z = vtx[i][2];
  865.     if (hasIntensity)
  866.       plyVert.intensity = vertIntensity[i];
  867.     
  868.     if (hasConfidence)
  869.       plyVert.confidence = vertConfidence[i];
  870.     
  871.     if (hasColor) {
  872.       plyVert.diff_r = vertMatDiff[i][0];
  873.       plyVert.diff_g = vertMatDiff[i][1];
  874.       plyVert.diff_b = vertMatDiff[i][2];
  875.     }
  877.     if (writeNormals) {
  878.       plyVert.nx = nrm[i][0];
  879.       plyVert.ny = nrm[i][1];
  880.       plyVert.nz = nrm[i][2];
  881.     }
  883.     /*
  884.     if (hasTexture && !useColorNotTexture) {
  885.       plyVert.tex_u = texture[i][0];
  886.       plyVert.tex_v = texture[i][1];
  887.     } 
  888.     else if (hasTexture && useColorNotTexture) {
  889.       float texU = texture[i][0];
  890.       float texV = texture[i][1];
  891.       int xOff = int(texU*meshSet->texXdim);
  892.       int yOff = int(texV*meshSet->texYdim);
  894.       // shouldn't that be texXdim, not texYdim*yOff ??
  895.       uchar *col = &meshSet->
  896. texture[3*(xOff + meshSet->texYdim*yOff)];
  898.       plyVert.diff_r = col[0];
  899.       plyVert.diff_g = col[1];
  900.       plyVert.diff_b = col[2];
  901.     }
  902.     */
  903.     ply.put_element((void *) &plyVert);
  904.   }
  905.   PlyFace plyFace;
  907.   ply.put_element_setup("face");
  909.   for (i = 0; i < tris.size(); i+=3) {
  910.     plyFace.nverts = 3;
  911.     plyFace.verts[0] = tris[i+0];
  912.     plyFace.verts[1] = tris[i+1];
  913.     plyFace.verts[2] = tris[i+2];
  914.     ply.put_element_static_strg((void *) &plyFace);
  915.   }
  917.   return 1;  
  918. #endif
  919. }
  922. static Random rnd;
  924. void
  925. Mesh::subsample_points(float rate, vector<Pnt3> &pts)
  926. {
  927.   subsample_points(int(rate*vtx.size()), pts);
  928. }
  931. void
  932. Mesh::subsample_points(float rate, vector<Pnt3> &pts,
  933.        vector<Pnt3> &nrms)
  934. {
  935.   subsample_points(int(rate*vtx.size()), pts, nrms);
  936. }
  939. bool
  940. Mesh::subsample_points(int n, vector<Pnt3> &pts)
  941. {
  942.   pts.clear(); pts.reserve(n);
  943.   double nv = vtx.size();
  944.   if (n > nv) return 0;
  945.   double np = n;
  946.   int end = nv;
  947.   for (int i = 0; i<end; i++) {
  948.     if (rnd(nv) <= np) {
  949.       pts.push_back(vtx[i]);   // save point
  950.       np--;
  951.     }
  952.     nv--;
  953.   }
  954.   assert(np == 0);
  955.   return 1;
  956. }
  959. bool
  960. Mesh::subsample_points(int n, vector<Pnt3> &pts, 
  961.        vector<Pnt3> &nrms)
  962. {
  963.   pts.clear(); pts.reserve(n);
  964.   nrms.clear(); nrms.reserve(n);
  965.   double nv = vtx.size();
  966.   if (n > nv) return 0;
  967.   double np = n;
  968.   int end = nv;
  969.   for (int i = 0; i<end; i++) {
  970.     if (rnd(nv) <= np) {
  971.       pts.push_back(vtx[i]);    // save point
  972.       pushNormalAsPnt3 (nrms, nrm.begin(), i);
  973.       np--;
  974.     }
  975.     nv--;
  976.   }
  977.   assert(np == 0);
  978.   return 1;
  979. }
  982. void
  983. Mesh::remove_unused_vtxs(void)
  984. {
  985.   // prepare vertex index map
  986.   vector<int> vtx_ind(vtx.size(), -1);
  987.   
  988.   // march through the triangles
  989.   // and mark the vertices that are actually used
  990.   int n = getTris().size();
  991.   for (int i=0; i<n; i++) {
  992.     assert (tris[i] >= 0 && tris[i] < vtx.size());
  993.     vtx_ind[tris[i]] = tris[i];
  994.   }
  996.   // remove the vertices that were not marked,
  997.   // also keep tab on how the indices change
  998.   int cnt = 0;
  999.   n = vtx.size();
  1000.   for (i=0; i<n; i++) {
  1001.     if (vtx_ind[i] != -1) {
  1002.       vtx_ind[i] = cnt;
  1003.       copyVertFrom (this, i, cnt);
  1004.       cnt++;
  1005.     }
  1006.   }
  1007.   vtx.erase(&vtx[cnt], vtx.end());
  1008.   if (nrm.size()) nrm.erase(&nrm[cnt*3], nrm.end());
  1009.   // march through triangles and correct the indices
  1010.   n = tris.size();
  1011.   for (i=0; i<n; i++) {
  1012.     tris[i] = vtx_ind[tris[i]];
  1013.     assert (tris[i] >=0 && tris[i] < vtx.size());
  1014.   }
  1015. }
  1017. // find the median edge length
  1018. // if a triangle has an edge that's longer than
  1019. // factor times the median (or percentile), remove the triangle
  1020. void
  1021. Mesh::remove_stepedges(int percentile, int factor)
  1022. {
  1023.   ::remove_stepedges(vtx, getTris(), factor, percentile);
  1024.   remove_unused_vtxs();
  1025.   freeTStrips();
  1026. }
  1029. static Pnt3 GetNrm (const vector<short>& nrm, int ivert)
  1030. {
  1031.   ivert *= 3;
  1032.   Pnt3 n (nrm[ivert], nrm[ivert+1], nrm[ivert+2]);
  1033.   n /= 32767.0;
  1034.   return n;
  1035. }
  1038. void
  1039. Mesh::simulateFaceNormals (vector<short>& facen)
  1040. {
  1041.   facen.clear();
  1042.   facen.reserve (getTris().size());
  1044.   // note: Mesh doesn't store per tri normals any more
  1045.   for (int i = 0; i < tris.size(); i+=3) {
  1046.     Pnt3 n  = GetNrm (nrm, tris[i+0]);
  1047.     n += GetNrm (nrm, tris[i+1]);
  1048.     n += GetNrm (nrm, tris[i+2]);
  1049.     n /= 3.0;
  1051.     pushNormalAsShorts (facen, n);
  1052.   }
  1053. }
  1056. // added by wsh for warping violin meshes (test stuff)
  1057. // A little dangerous 'cuz we're fudging the verticies as we go
  1058. void
  1059. Mesh::Warp()
  1060. {
  1061.   printf("(%f, %f, %f)n", center[0], center[1], center[2]);
  1063.   for ( vector<Pnt3>::iterator i = vtx.begin();
  1064. i != vtx.end();
  1065. i++ ) {
  1066.     (*i)[2] += 7 * cos(0.017674205 * (*i)[1]) + 
  1067.       5 * cos(0.030921161  * (*i)[0]);
  1068.   }
  1069. }
  1071. /***************************************************************************
  1072.                D E Q U A N T I Z A T I O N S M O O T H I N G 
  1073. ***************************************************************************/
  1074. void Mesh::dequantizationSmoothing(double maxDisplacement)
  1075. {
  1076.   cout << "Number of verts: " << vtx.size() << endl;
  1078.   // Make sure we have the inverse table
  1079.   calcTriLists();
  1080.   
  1081.   // Get a structure for new points of appropriate size
  1082.   vector<Pnt3> nvtx;
  1083.   nvtx=vtx;
  1084.   printf ("size nvtx %ldn",nvtx.size());
  1086.   // print info every how many tris? (mod count)
  1087.   int mc= 100000;
  1088.   
  1089.   // Loop over every vtx, blurring
  1090.   for (int i=0;i<vtx.size();i++)
  1091.     {
  1092.       if (i%mc==0) printf("Vertex Number %d tri count %ldn ",
  1093.   i,vtxTris[i].size());
  1094.       
  1095.       Pnt3 pnt(0,0,0);
  1096.       double w=0;
  1097.       // Loop over all tris touching this vert
  1098.       for (TriListI j=vtxTris[i].begin();j!=vtxTris[i].end();j++)
  1099. {
  1100.   if (i%mc==0) printf("  Tri Number: %dn",(*j));
  1101.   
  1102.   // Loop over all verts in adjacent tri
  1103.   // note that we end up double counting verts
  1104.   for (int k=0;k<3;k++)
  1105.     {
  1106.       w++;
  1107.       Pnt3 npnt=vtx[tris[(*j)*3+k]];
  1108.       if (i%mc==0) printf ("    Vtx %f  %f  %fn",npnt[0],npnt[1],npnt[2]);
  1109.       if (i%mc==0) printf ("      Pnt %f  %f  %fn",pnt[0],pnt[1],pnt[2]);
  1110.       pnt= pnt + npnt;
  1111.       if (i%mc==0) printf ("      Pnt %f  %f  %fn",pnt[0],pnt[1],pnt[2]);
  1112.     }
  1113. }
  1114.       // Divide the weight ,( number of verts) out
  1115.       pnt= pnt / w;
  1117.       // Check the distance, so that we constrain.
  1118.       
  1119.       // Assign the new value
  1120.       nvtx[i]=pnt;
  1121.     }
  1123.   printf ("size nvtx %ldn",nvtx.size());
  1124.   
  1125.   // Copy new points to main store
  1126.   vtx=nvtx;
  1128.   puts ("finish");
  1129. }
  1131. /***************************************************************************
  1132.                       R E S T O R E O R I G V E R T S 
  1133. ***************************************************************************/
  1134. void Mesh::restoreOrigVerts()
  1135. {
  1136.   // Don't restore if we never saved away the original
  1137.   if (orig_vtx.size()==vtx.size())
  1138.     {
  1139.       vtx=orig_vtx;
  1140.     }
  1141.   else if (orig_vtx.size()==0)
  1142.     {
  1143.       saveOrigVerts();
  1144.     }
  1145. }
  1147. /***************************************************************************
  1148.                          S A V E O R I G V E R T S 
  1149. ***************************************************************************/
  1150. void Mesh::saveOrigVerts()
  1151. {
  1152.   orig_vtx=vtx;
  1153. }
  1155. /***************************************************************************
  1156.                           C A L C T R I L I S T S 
  1157. ***************************************************************************/
  1158. void Mesh::calcTriLists()
  1159. {
  1161.   // Don't bother if we already did it
  1162.   if (vtxTris.size()==vtx.size()) return;
  1163.   
  1164.   // Insure that we have the tris structure
  1166.   // Size the vtxTris structure correctly
  1167.   TriList empty;
  1168.   for (int j=0;j<vtx.size();j++)
  1169.     {
  1170.       vtxTris.push_back(empty);
  1171.     }
  1173.   cout << "sizes match?  " << vtxTris.size() << " " << vtx.size() << endl;
  1175.   vector<int>&ltris=getTris();
  1177.   int triSize=ltris.size()/3;
  1178.   int vtxSize=vtx.size();
  1179.   
  1180.   
  1181.   cout << "Number of tris " << triSize << endl;
  1182.   
  1183.   // Fill in the structure
  1184.   for (int i=0;i<triSize*3;i++)
  1185.     {
  1186.       int curtri=i/3;
  1187.       assert(curtri<triSize);
  1188.       
  1189.       int curvert=ltris[i];
  1190.       assert(curvert<vtxSize);
  1192.       //printf ("before %dn",vtxTris[curvert].size());
  1193.       vtxTris[curvert].insert(curtri);
  1194.       //printf ("after %dn",vtxTris[curvert].size());
  1195.     }
  1196. }