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

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

3D图形编程

开发平台：

Visual C++

plyio.cc：源码内容
  1. #include <stdio.h>
  2. #include "ply++.h"
  3. #include <stdlib.h>
  4. #include "strings.h"
  5. #include <iostream.h>
  6. #include <limits.h>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #ifdef WIN32
  10. #else
  11. #include <unistd.h>
  12. #include <fcntl.h>
  13. #endif
  14. #include "timer.h"
  16. #include "vector.h"
  18. #include "Mesh.h"
  19. #include "plyio.h"
  21. #define SHOW(x) cout << #x " = " << x << endl
  23. static int Verbose = 1;
  25. struct PlyVertex {
  26.   float x, y, z;
  27.   float nx, ny, nz;
  28.   uchar diff_r, diff_g, diff_b;
  29.   float tex_u, tex_v;
  30.   float intensity;
  31.   float std_dev;
  32.   float confidence;
  33. };
  35. const int MAX_FACE_VERTS = 100;
  37. struct PlyFace {
  38.   uchar nverts;
  39.   int verts[MAX_FACE_VERTS];
  40. };
  43. struct CoordConfVert {
  44.    float v[3];
  45.    float conf;
  46. };
  48. struct TriLocal {
  49.    uchar nverts;
  50.    int index[3];
  51. };
  54. static PlyProperty vert_prop_x =  
  55.    {"x", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  56. static PlyProperty vert_prop_y =  
  57.   {"y", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  58. static PlyProperty vert_prop_z =  
  59.   {"z", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  60. static PlyProperty vert_prop_nx =  
  61.    {"nx", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  62. static PlyProperty vert_prop_ny =  
  63.   {"ny", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  64. static PlyProperty vert_prop_nz =  
  65.   {"nz", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  66. static PlyProperty vert_prop_texture_u =  
  67.   {"texture_u", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  68. static PlyProperty vert_prop_texture_v =  
  69.   {"texture_v", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  70. static PlyProperty vert_prop_intens =  
  71.   {"intensity", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  72. static PlyProperty vert_prop_std_dev =  
  73.   {"std_dev", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  74. static PlyProperty vert_prop_confidence =  
  75.   {"confidence", PLY_FLOAT, PLY_FLOAT, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  76. static PlyProperty vert_prop_diff_r =  
  77.   {"diffuse_red", PLY_UCHAR, PLY_UCHAR, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  78. static PlyProperty vert_prop_diff_g =  
  79.   {"diffuse_green", PLY_UCHAR, PLY_UCHAR, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  80. static PlyProperty vert_prop_diff_b =  
  81.   {"diffuse_blue", PLY_UCHAR, PLY_UCHAR, 0, 0, PLY_START_TYPE, PLY_START_TYPE, 0};
  83. static PlyProperty face_props[] = { 
  84.   {"vertex_indices", PLY_INT, PLY_INT, 0, 1, PLY_UCHAR, PLY_UCHAR, 0},
  85.   //{"vertex_indices", PLY_INT, PLY_INT, 4, 1, PLY_INT, PLY_INT, 0},
  86. };
  88. static PlyProperty tstrips_props[] = {
  89.   {"vertex_indices", PLY_INT, PLY_INT, 4, 1, PLY_INT, PLY_INT, 0},
  90. };
  92. static Mesh *oldReadPlyFile(char *filename);
  93. static Mesh *mattReadPlyFile(char *filename);
  95. static void
  96. set_offsets(void)
  97. {
  98.   static int first = 1;
  99.   if (first) {
  100.     first = 0;
  101.     vert_prop_x.offset          = offsetof(PlyVertex,x);
  102.     vert_prop_y.offset          = offsetof(PlyVertex,y);
  103.     vert_prop_z.offset          = offsetof(PlyVertex,z);
  104.     vert_prop_nx.offset         = offsetof(PlyVertex,nx);
  105.     vert_prop_ny.offset         = offsetof(PlyVertex,ny);
  106.     vert_prop_nz.offset         = offsetof(PlyVertex,nz);
  107.     vert_prop_intens.offset     = offsetof(PlyVertex, intensity);
  108.     vert_prop_std_dev.offset    = offsetof(PlyVertex, std_dev);
  109.     vert_prop_confidence.offset = offsetof(PlyVertex, confidence);
  110.     vert_prop_diff_r.offset     = offsetof(PlyVertex,diff_r);
  111.     vert_prop_diff_g.offset     = offsetof(PlyVertex,diff_g);
  112.     vert_prop_diff_b.offset     = offsetof(PlyVertex,diff_b);
  113.     vert_prop_texture_u.offset  = offsetof(PlyVertex,tex_u);
  114.     vert_prop_texture_v.offset  = offsetof(PlyVertex,tex_v);
  115.   }
  116. }
  118. Mesh *
  119. readPlyFile(char *filename)
  120. {
  121.   /*
  122.   //Mesh* mesh = mattReadPlyFile (filename);
  123.   //if (mesh == NULL) {
  124.     Mesh *mesh = oldReadPlyFile (filename);
  125.     if (mesh != NULL)
  126.       //printf ("Warning: file %s does not conform to dmich'sn"
  127.       //      "expected ply layout; cannot use fastread code.n", 
  128.       //      filename);
  129.       printf ("Warning: using oldReadPlyFile()n");
  130.     else
  131.       printf ("Cannot read plyfile %sn", filename);
  132.     //}
  133.   */
  134.   Mesh *mesh = new Mesh;
  135.   if (mesh->readPlyFile (filename)) {
  136.     return mesh;
  137.   }
  138.   delete mesh;
  139.   return NULL;
  140. }
  143. //
  144. // Read in data from the ply file
  145. //
  146. /*
  147. Mesh *
  148. oldReadPlyFile(char *filename)
  149. {
  150.   int i, j;
  151.   int nelems;
  152.   char **elist;
  153.   char **obj_info;
  154.   int num_obj_info;
  155.   char *elem_name;
  156.   int nprops;
  157.   int num_elems;
  158.   int hasNormals = 0;
  159.   int hasConfidence = 0;
  160.   int hasIntensity = 0;
  161.   int hasStdDev = 0;
  162.   int hasDiffuseColors = 0;
  163.   int notATriangleMesh = 0;
  164.   int hasTexture = 0;
  165.   int skipTexture = 1;
  166.   char texFile[PATH_MAX];
  168.   Timer t ("Read ply file (via plylib)");
  170.   face_props[0].offset = offsetof(PlyFace, verts);
  171.   face_props[0].count_offset = offsetof(PlyFace, nverts);  // count offset
  172.     
  173.   PlyFile ply;
  174.   if (ply.open_for_reading(filename, &nelems, &elist) == 0)
  175.     return NULL;
  177.   Mesh *mesh = new Mesh;
  179.   // Look for a texture file reference
  180.   char temp[PATH_MAX];
  181.   obj_info = ply.get_obj_info (&num_obj_info);
  182.   for (i = 0; i < num_obj_info; i++) {
  183.     if (strstr(obj_info[i], "texture_file")) {
  184.       sscanf(obj_info[i], "%s%s", temp, texFile);
  185.       FILE *fp = fopen(texFile, "r");
  186.       if (fp != NULL) {
  187. fclose(fp);
  188. skipTexture = 0;
  189. strcpy(mesh->texFileName, texFile);
  190.       }
  191.     }
  192.   }
  193.    
  194.   vector<PlyProperty> vert_props;
  196.   set_offsets();
  198.   Vertex *vert;
  199.   PlyVertex plyVert;
  200.   PlyFace plyFace;
  202.   for (i = 0; i < nelems; i++) {
  204.     // get the description of the first element
  205.     elem_name = elist[i];
  206.     ply.get_element_description(elem_name, &num_elems, &nprops);
  208.     // if we're on vertex elements, read them in
  209.     if (equal_strings ("vertex", elem_name)) {
  210.     
  211.       Timer tv ("Read vertices");
  213.       mesh->numVerts = num_elems;
  214.       mesh->verts = new Vertex[num_elems];
  215.     
  216.       if (ply.is_valid_property("vertex", vert_prop_x.name) &&
  217.   ply.is_valid_property("vertex", vert_prop_y.name) &&
  218.   ply.is_valid_property("vertex", vert_prop_z.name)) {
  219. ply.get_property(elem_name, &vert_prop_x);
  220. ply.get_property(elem_name, &vert_prop_y);
  221. ply.get_property(elem_name, &vert_prop_z);
  222.       }
  223.   
  224.       if (ply.is_valid_property("vertex", vert_prop_nx.name) &&
  225.   ply.is_valid_property("vertex", vert_prop_ny.name) &&
  226.   ply.is_valid_property("vertex", vert_prop_nz.name) ) {
  227. ply.get_property(elem_name, &vert_prop_nx);
  228. ply.get_property(elem_name, &vert_prop_ny);
  229. ply.get_property(elem_name, &vert_prop_nz);
  230. hasNormals = 1;
  231.       }
  232.       mesh->hasVertNormals = hasNormals;
  233.   
  234.       if (ply.is_valid_property("vertex", vert_prop_intens.name)) {
  235. ply.get_property(elem_name, &vert_prop_intens);
  236. hasIntensity = 1;
  237.       }
  238.     
  239.       if (ply.is_valid_property("vertex", vert_prop_std_dev.name)){
  240. ply.get_property(elem_name, &vert_prop_std_dev);
  241. hasStdDev = 1;
  242.       }
  243.     
  244.       if (ply.is_valid_property("vertex", 
  245. vert_prop_confidence.name)) {
  246. ply.get_property(elem_name, &vert_prop_confidence);
  247. hasConfidence = 1;
  248. mesh->vertConfidence = new float[num_elems];
  249.       }
  250.     
  251.       if (ply.is_valid_property("vertex", "diffuse_red") &&
  252.   ply.is_valid_property("vertex", "diffuse_green") &&
  253.   ply.is_valid_property("vertex", "diffuse_blue")) {
  254. ply.get_property(elem_name, &vert_prop_diff_r);
  255. ply.get_property(elem_name, &vert_prop_diff_g);
  256. ply.get_property(elem_name, &vert_prop_diff_b);
  257. hasDiffuseColors = 1;
  258. mesh->vertMatDiff = new vec3uc[num_elems];
  259.       }
  260.     
  261.       if (!skipTexture) {
  262. if (ply.is_valid_property("vertex", "texture_u") &&
  263.     ply.is_valid_property("vertex", "texture_v")) {
  264.   ply.get_property(elem_name, &vert_prop_texture_u);
  265.   ply.get_property(elem_name, &vert_prop_texture_v);
  266.   hasTexture = 1;
  267.   mesh->texture = new vec2f[num_elems];
  268. }
  269.       }
  271.       if (Verbose) cout << "Reading vertices..." << endl;
  273.       SHOW(mesh->numVerts);
  275.       // grab all the vertex elements
  276.       for (j = 0; j < mesh->numVerts; j++) {
  277. ply.get_element ((void *) &plyVert);
  278. vert = &mesh->verts[j];
  280. vert->coord.setValue(plyVert.x, plyVert.y, plyVert.z);
  282. if (hasNormals) {
  283.   vert->norm.setValue(plyVert.nx, plyVert.ny, plyVert.nz);
  284. }
  286. if (hasDiffuseColors) {
  287.   mesh->vertMatDiff[j][0] = plyVert.diff_r;
  288.   mesh->vertMatDiff[j][1] = plyVert.diff_g;
  289.   mesh->vertMatDiff[j][2] = plyVert.diff_b;
  290. }
  292. if (hasConfidence) {
  293.   mesh->vertConfidence[j] = plyVert.confidence;
  294. }
  296. if (hasTexture) {
  297.   mesh->texture[j][0] = plyVert.tex_u;
  298.   mesh->texture[j][1] = plyVert.tex_v;
  299. }
  300.       }
  302.       if (Verbose) cout << "Done." << endl;
  304.     }
  306.     if (equal_strings ("face", elem_name)) {
  308.       Timer tf ("Read faces");
  310.       ply.get_property(elem_name, face_props);
  312.       assert(mesh->tris.size() == 0);
  314.       if (num_elems == 0)
  315. continue;
  317.       if (Verbose) cout << "Reading Tris..." << endl;
  319.       SHOW(num_elems);
  320.       for (j = 0; j < num_elems; j++) {
  321. ply.get_element_noalloc((void *) &plyFace);
  322. if (plyFace.nverts != 3)
  323.   notATriangleMesh = 1;
  324. assert(plyFace.nverts <= MAX_FACE_VERTS);
  325. mesh->tris.push_back(Triangle(plyFace.verts[0],
  326.       plyFace.verts[1],
  327.       plyFace.verts[2]));
  328. //delete[] plyFace.verts;
  329.       }
  331.       if (notATriangleMesh) {
  332. cerr << "readPlyFile: Not a triangle mesh!" << endl;
  333.       }
  335.       if (Verbose) cout << "Done." << endl;
  336.     }
  338.     if (equal_strings ("tristrips", elem_name)) {
  340.       struct {
  341. int nverts; int* vertData;
  342.       } info;
  344.       if (num_elems != 1)
  345. continue;
  347.       if (Verbose) cout << "Reading TStrips..." << endl;
  349.       ply.get_property(elem_name, tstrips_props);
  350.       ply.get_element ((void*)&info);
  351.       mesh->tstrips = new vector<int> (info.nverts);
  352.       for (int iv = 0; iv < info.nverts; iv++) {
  353. mesh->tstrips->push_back (info.vertData[iv]);
  354.       }
  356.       mesh->trisFromStrip();
  358.       if (Verbose) cout << "Done." << endl;
  359.     }
  360.   }
  362.   return mesh;
  363. }
  364. */
  366. int SizeOfProp[] = { 0, 1, 2, 4, 1, 2, 4, 4, 8 };
  367. int 
  368. CalcPropertySize (PlyElement* elem)
  369. {
  370.   int size = 0;
  371.   int type;
  373.   /*
  374.   for (int i = 0; i < elem->nprops; i++) {
  375.     type = elem->props[i]->external_type;
  376.     if (type <= PLY_START_TYPE || type >= PLY_END_TYPE) {
  377.       printf ("Unknown type %d found for property %s in elem %sn",
  378.       type, elem->props[i]->name, elem->name);
  379.       return 0;
  380.     }
  381.   */
  382.   for (int i = 0; i < elem->props.size(); i++) {
  383.     type = elem->props[i].external_type;
  384.     if (type <= PLY_START_TYPE || type >= PLY_END_TYPE) {
  385.       printf ("Unknown type %d found for property %s in elem %sn",
  386.       type, elem->props[i].name, elem->name);
  387.       return 0;
  388.     }
  389.     size += SizeOfProp[type];
  390.   }
  392.   return size;
  393. }
  396. #if defined(WIN32) || defined(i386)
  397. void 
  398. CopyReverseWord (void* dest, void* src, int nWords)
  399.   //like memcpy but copies 32-bit words instead of bytes, and flips byte order
  400.   //to convert endian-ness as it copies.  Used to read PLY files (which are
  401.   //currently all big-endian) on PC's (which are little-endian).
  402. {
  403.   for (int i = 0; i < nWords; i++) {
  404.     unsigned long temp = *(unsigned long*)src;
  405.     
  406.     temp = (temp >> 24) | ((temp >> 8) & 0xFF00) | 
  407.       ((temp << 8) & 0xFF0000) | (temp << 24);
  409.     (*(unsigned long*)dest) = temp;
  410.     src  = ((char*)src)  + 4;
  411.     dest = ((char*)dest) + 4;
  412.   }
  413. }
  414. #endif
  416. Mesh*
  417. mattReadPlyFile (char* filename)
  418. {
  419.   /*
  420.     int nelems;
  421.     char **elist;
  422.     char **obj_info;
  423.     int num_obj_info;
  424.     int file_type;
  425.     float version;
  426.     bool skipTexture = FALSE;
  427.     char texFile[PATH_MAX];
  429.     Timer t ("Read ply file (Matt's way)");
  431.     PlyFile *ply = 
  432. ply_open_for_reading(filename, &nelems, &elist, &file_type, &version);
  434.     if (!ply)
  435. return NULL;
  437.     if (file_type != PLY_BINARY_BE)  //if it ever becomes an issue, the code
  438.         return NULL;  //is already here to read PLY_BINARY_LE too
  439.                       //but right now, none of these exist anyway
  441.     Mesh *mesh = new Mesh;
  443.     // Look for a texture file reference
  444.     char temp[PATH_MAX];
  445.     obj_info = ply_get_obj_info (ply, &num_obj_info);
  446.     for (int i = 0; i < num_obj_info; i++) {
  447. if (strstr(obj_info[i], "texture_file")) {
  448.     sscanf(obj_info[i], "%s%s", temp, texFile);
  449.     FILE *fp = fopen(texFile, "r");
  450.     if (fp != NULL) {
  451. fclose(fp);
  452. skipTexture = TRUE;
  453. strcpy(mesh->texFileName, texFile);
  454.     }
  455. }
  456.     }
  457.     
  458.     if (strcmp (elist[0], "vertex") != 0)
  459.       return NULL;//first element must be vertex
  461.     if (strcmp (elist[1], "face") != 0 && strcmp (elist[1], "tristrips") != 0)
  462.       return NULL;//second element must be triangles or strips
  464.     //read in vertex data
  465.     int nVerts = ply->elems[0]->num;
  466.     int cbVertex = ply->elems[0]->size;
  467.     //if (cbVertex <= 0)
  468.     cbVertex = CalcPropertySize (ply->elems[0]);
  469.     char* vBuffer = new char[nVerts * cbVertex];
  470.     if (nVerts != fread (vBuffer, cbVertex, nVerts, ply->fp)) {
  471.         delete vBuffer;
  472. delete mesh;
  473. return NULL;
  474.     }
  476.     //read in face data, if available
  477. #if 0  // pack pragma is not supported by n32 compiler
  478. #pragma pack (1)
  479.     typedef struct { uchar nV; int vindex[3]; } RAWFACE;
  480.     static const int kRawFaceSize = sizeof(RAWFACE);
  481. #pragma pack (0)
  482. #else
  483.     static const int kRawFaceSize = 13;
  484. #endif
  486.     int nFaces;
  487.     char* pFaces;
  488.     int nStrips;
  489.     int* pStrips;
  490.     if (!strcmp (elist[1], "face")) {
  491.       nStrips = 0; pStrips = NULL;
  492.       nFaces = ply->elems[1]->num;
  493.       pFaces = new char [nFaces * kRawFaceSize];
  494.       if (nFaces != fread ((char*)pFaces, kRawFaceSize, nFaces, ply->fp)) {
  495.   delete vBuffer;
  496.   delete pFaces;
  497.   delete mesh;
  498.   return NULL;
  499.       }
  500.     } else {
  501.       //otherwise, tristrips
  502.       nFaces = 0; pFaces = NULL;
  503.       fread ((char*)&nStrips, sizeof(int), 1, ply->fp);
  504.       mesh->tstrips = new vector<int> (nStrips); //reserve space
  505.       pStrips = &(*mesh->tstrips)[0]; //and read right into it
  506.       if (1 != fread ((char*)pStrips, sizeof(int), nStrips, ply->fp)) {
  507.   delete vBuffer;
  508.   delete mesh->tstrips;
  509.   delete mesh;
  510.   return NULL;
  511.       }
  512.     }
  514.     //transfer
  515.     int ofsX = -1, ofsY = -1, ofsZ = -1;
  516.     int ofsNx = -1, ofsNy = -1, ofsNz = -1;
  517.     int ofsIntensity = -1, ofsConf = -1;
  518.     //int ofsStdDev = -1; //this was here but unused and causing warnings
  519.     int ofsD_Red = -1, ofsD_Green = -1, ofsD_Blue = -1;
  520.     int ofsTexU = -1, ofsTexV = -1;
  521.     
  522.     int ofs = 0;
  523.     for (i = 0; i < ply->elems[0]->nprops; i++) {
  524.       PlyProperty* pProp = ply->elems[0]->props[i];
  525.       if      (!strcmp (pProp->name, "x"))
  526. ofsX = ofs;
  527.       else if (!strcmp (pProp->name, "y"))
  528. ofsY = ofs;
  529.       else if (!strcmp (pProp->name, "z"))
  530. ofsZ = ofs;
  531.       else if (!strcmp (pProp->name, "nx"))
  532. ofsNx = ofs;
  533.       else if (!strcmp (pProp->name, "ny"))
  534. ofsNy = ofs;
  535.       else if (!strcmp (pProp->name, "nz"))
  536. ofsNz = ofs;
  537.       else if (!strcmp (pProp->name, "intensity"))
  538. ofsIntensity = ofs;
  539.       //else if (!strcmp (pProp->name, "std_dev"))
  540.       //  ofsStdDev = ofs;
  541.       else if (!strcmp (pProp->name, "confidence"))
  542. ofsConf = ofs;
  543.       else if (!strcmp (pProp->name, "diffuse_red"))
  544. ofsD_Red = ofs;
  545.       else if (!strcmp (pProp->name, "diffuse_green"))
  546. ofsD_Green = ofs;
  547.       else if (!strcmp (pProp->name, "diffuse_blue"))
  548. ofsD_Blue = ofs;
  549.       else if (!strcmp (pProp->name, "texture_u"))
  550. ofsTexU = ofs;
  551.       else if (!strcmp (pProp->name, "texture_v"))
  552. ofsTexV = ofs;
  554.       ofs += SizeOfProp [pProp->external_type];
  555.     }
  557.     assert (ofsX != -1 && ofsY != -1 && ofsZ != -1);
  558.     mesh->numVerts = nVerts;
  559.     mesh->verts = new Vertex[nVerts];
  560.     if (ofsConf != -1)
  561.       mesh->vertConfidence = new float[nVerts];
  562.     if (ofsIntensity != -1)
  563.       mesh->vertIntensity = new float[nVerts];
  564.     if (ofsNx != -1 && ofsNy == -1 && ofsNz == -1)
  565.       mesh->hasVertNormals = TRUE;
  566.     else
  567.       ofsNx = ofsNy = ofsNz = -1;
  568.     if (ofsD_Red != -1 && ofsD_Green != -1 && ofsD_Blue != -1)
  569.       mesh->vertMatDiff = new vec3uc[nVerts];
  570.     else
  571.       ofsD_Red = ofsD_Green = ofsD_Blue = -1;
  572.     if (ofsTexU != -1 && ofsTexV != -1 && !skipTexture) {
  573.       mesh->texture = new vec2f[nVerts];
  574.       mesh->hasTexture = TRUE;
  575.     }
  576.     else
  577.       ofsTexU = ofsTexV = -1;
  578.     //don't actually know what to do with std_dev data
  580.     //verify assumptions about what is stored contiguously
  581.     assert (ofsY == ofsX + sizeof(float));
  582.     assert (ofsZ == ofsY + sizeof(float));
  583.     if (ofsNx != -1) {
  584.       assert (ofsNy == ofsNx + sizeof(float));
  585.       assert (ofsNz == ofsNy + sizeof(float));
  586.     }
  587.     if (ofsD_Red != -1) {
  588.       assert (ofsD_Green == ofsD_Red + sizeof(uchar));
  589.       assert (ofsD_Blue == ofsD_Green + sizeof(uchar));
  590.     }
  591.     if (ofsTexU != -1)
  592.       assert (ofsTexV == ofsTexU + sizeof(float));
  594.     char* vert;
  595.     for (vert = vBuffer, i = 0; i < nVerts;
  596.  vert += cbVertex, i++) {
  597. #if defined(WIN32) || defined(i386)
  598.       CopyReverseWord (&mesh->verts[i].coord, vert + ofsX, 3);
  599.       if (ofsNx != -1)
  600. CopyReverseWord (&mesh->verts[i].norm, vert + ofsNx, 3);
  601.       if (ofsD_Red != -1)
  602. memcpy (mesh->vertMatDiff+i, vert + ofsD_Red, 3*sizeof(uchar));
  603.       if (ofsTexU != -1)
  604. CopyReverseWord (mesh->texture+i, vert + ofsTexU, 2);
  605.       if (ofsIntensity != -1)
  606. CopyReverseWord (mesh->vertIntensity+i, vert + ofsIntensity, 1);
  607.       if (ofsConf != -1)
  608. CopyReverseWord (mesh->vertConfidence+i, vert + ofsConf, 1);
  609. #else
  610.       memcpy (&mesh->verts[i].coord, vert + ofsX, 3*sizeof(float));
  611.       if (ofsNx != -1)
  612. memcpy (&mesh->verts[i].norm, vert + ofsNx, 3*sizeof(float));
  613.       if (ofsD_Red != -1)
  614. memcpy (mesh->vertMatDiff+i, vert + ofsD_Red, 3*sizeof(uchar));
  615.       if (ofsTexU != -1)
  616. memcpy (mesh->texture+i, vert + ofsTexU, 2*sizeof(float));
  617.       if (ofsIntensity != -1)
  618. memcpy (mesh->vertIntensity+i, vert + ofsIntensity, sizeof(float));
  619.       if (ofsConf != -1)
  620. memcpy (mesh->vertConfidence+i, vert + ofsConf, sizeof(float));
  621. #endif
  622.     }
  623.     delete vBuffer;
  625.     if (nFaces) {
  626.       assert(mesh->tris.size() == 0);
  627.       mesh->tris.reserve (nFaces);
  629.       char* pFace;
  630.       char* endFaces = pFaces + (nFaces*kRawFaceSize);
  631.       for (pFace = pFaces; pFace < endFaces; pFace += kRawFaceSize) {
  632. if (*pFace !=3 ) fprintf(stderr, "nV = %dn", (int)*pFace);
  633. assert (*pFace == 3);
  635. mesh->tris.push_back(Triangle());
  636. Triangle *pTri = mesh->tris.end()-1;
  637. #if defined(WIN32) || defined(i386)
  638. CopyReverseWord (&pTri->vindex1, pFace + 1, 3);
  639. #else
  640. memcpy (&pTri->vindex1, pFace + 1, kRawFaceSize - 1);
  641. #endif
  642.       }
  644.       delete pFaces;
  646.     } else {
  648.       //already have data in tstrips vector
  649.       mesh->trisFromStrip();
  650.     }
  652.     ply_close(ply);
  654.     return mesh;
  655.   */
  656.   return NULL;
  657. }
  661. int
  662. writePlyFile(char *filename, MeshSet *meshSet, 
  663.      int level, int useColorNotTexture, int writeNormals)
  664. {
  665. #if 1
  666.   return meshSet->meshes[level]->writePlyFile(filename,
  667.       useColorNotTexture,
  668.       writeNormals,
  669.       meshSet);
  670. #else
  671.   int i;
  672.   int hasIntensity;
  673.   int hasColor;
  674.   int hasConfidence;
  675.   int hasTexture;
  676.   char *elem_names[] = {"vertex", "face"};
  678.   Mesh *mesh = meshSet->meshes[level];
  680.   hasIntensity = mesh->vertIntensity != NULL;
  681.   hasColor = mesh->vertMatDiff != NULL;
  682.   hasConfidence = mesh->vertConfidence != NULL;
  683.   hasTexture = mesh->texture != NULL;
  686.   PlyFile ply;
  687.   if (!ply.open_for_writing(filename, 2, elem_names,PLY_BINARY_BE))
  688.     return 0;
  690.   if (hasTexture && !useColorNotTexture) {
  691.     char obj_info[PATH_MAX];
  692.     sprintf(obj_info, "%s %s", "texture_file", mesh->texFileName);
  693.     ply.put_obj_info(obj_info);
  694.   }
  696.   vector<PlyProperty> vert_props;
  697.   set_offsets();
  699.   vert_props.push_back(vert_prop_x);
  700.   vert_props.push_back(vert_prop_y);
  701.   vert_props.push_back(vert_prop_z);
  703.   if (writeNormals) {
  704.     vert_props.push_back(vert_prop_nx);
  705.     vert_props.push_back(vert_prop_ny);
  706.     vert_props.push_back(vert_prop_nz);
  707.   }
  709.   if (hasIntensity) {
  710.     vert_props.push_back(vert_prop_intens);
  711.   }
  712.     
  713.   if (hasConfidence) {
  714.     vert_props.push_back(vert_prop_confidence);
  715.     hasConfidence = 1;
  716.   }
  717.     
  718.   if (hasColor || (hasTexture && useColorNotTexture)) {
  719.     vert_props.push_back(vert_prop_diff_r);
  720.     vert_props.push_back(vert_prop_diff_g);
  721.     vert_props.push_back(vert_prop_diff_b);
  722.   }
  723.     
  724.   if (hasTexture && !useColorNotTexture) {
  725.     vert_props.push_back(vert_prop_texture_u);
  726.     vert_props.push_back(vert_prop_texture_v);
  727.   }
  729.   // count offset
  730.   face_props[0].offset = offsetof(PlyFace, verts);
  731.   face_props[0].count_offset = offsetof(PlyFace, nverts);  
  732.     
  733.   ply.describe_element("vertex", mesh->numVerts, 
  734. vert_props.size(), &vert_props[0]);
  735.   ply.describe_element("face", mesh->tris.size(), 1, face_props);
  736.   ply.header_complete();
  737.     
  738.     // set up and write the vertex elements
  739.   PlyVertex plyVert;
  740.   Vertex *vert;
  742.   ply.put_element_setup("vertex");
  744.   for (i = 0; i < mesh->numVerts; i++) {
  745.     vert = &mesh->verts[i];
  746.     plyVert.x = vert->coord.x;
  747.     plyVert.y = vert->coord.y;
  748.     plyVert.z = vert->coord.z;
  750.     if (hasIntensity)
  751.       plyVert.intensity = mesh->vertIntensity[i];
  752.     
  753.     if (hasConfidence)
  754.       plyVert.confidence = mesh->vertConfidence[i];
  755.     
  756.     if (hasColor) {
  757.       plyVert.diff_r = mesh->vertMatDiff[i][0];
  758.       plyVert.diff_g = mesh->vertMatDiff[i][1];
  759.       plyVert.diff_b = mesh->vertMatDiff[i][2];
  760.     }
  762.     if (writeNormals) {
  763.       plyVert.nx = vert->norm.x;
  764.       plyVert.ny = vert->norm.y;
  765.       plyVert.nz = vert->norm.z;
  766.     }
  768.     if (hasTexture && !useColorNotTexture) {
  769.       plyVert.tex_u = mesh->texture[i][0];
  770.       plyVert.tex_v = mesh->texture[i][1];
  771.     } 
  772.     else if (hasTexture && useColorNotTexture) {
  773.       float texU = mesh->texture[i][0];
  774.       float texV = mesh->texture[i][1];
  775.       int xOff = int(texU*meshSet->texXdim);
  776.       int yOff = int(texV*meshSet->texYdim);
  778.       // shouldn't that be texXdim, not texYdim*yOff ??
  779.       uchar *col = &meshSet->
  780. texture[3*(xOff + meshSet->texYdim*yOff)];
  782.       plyVert.diff_r = col[0];
  783.       plyVert.diff_g = col[1];
  784.       plyVert.diff_b = col[2];
  785.     }
  787.     ply.put_element((void *) &plyVert);
  788.   }
  789.   PlyFace plyFace;
  790.   Triangle *tri;
  792.   ply.put_element_setup("face");
  794.   for (i = 0; i < mesh->tris.size(); i++) {
  795.     tri = &mesh->tris[i];
  796.     plyFace.nverts = 3;
  797.     /*
  798.     vertIndices[0] = tri->vindex1;
  799.     vertIndices[1] = tri->vindex2;
  800.     vertIndices[2] = tri->vindex3;
  801.     plyFace.verts = (int *)vertIndices;
  802.     */
  803.     plyFace.verts[0] = tri->vindex1;
  804.     plyFace.verts[1] = tri->vindex2;
  805.     plyFace.verts[2] = tri->vindex3;
  807.     ply.put_element_static_strg((void *) &plyFace);
  808.   }
  810.   return 1;
  811. #endif
  812. }