manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/wrap/nanoply/include/nanoply.hpp

1695 lines
55 KiB
C++
Raw Blame History

/****************************************************************************
* NanoPLY *
* NanoPLY is a C++11 header-only library to read and write PLY file *
* *
* Copyright(C) 2014 *
* Visual Computing Lab *
* ISTI - Italian National Research Council *
* *
* This Source Code Form is subject to the terms of the Mozilla Public *
* License, v. 2.0. If a copy of the MPL was not distributed with this *
* file, You can obtain one at http://mozilla.org/MPL/2.0/. *
* *
****************************************************************************/
#ifndef NANOPLY_HPP
#define NANOPLY_HPP
#include <vector>
#include <tuple>
#include <cassert>
#include <algorithm>
#include <stdexcept>
#include <cstdio>
#include <cmath>
#include <limits>
#include <stdint.h>
// Avoid conflicting declaration of min/max macros in windows headers
#if !defined(NOMINMAX) && (defined(_WIN32) || defined(_WIN32_) || defined(WIN32) || defined(_WIN64))
# define NOMINMAX
# ifdef max
# undef max
# undef min
# endif
#endif
#define USE_H4D_OUTPUT
namespace nanoply
{
/**
* @cond HIDDEN_SYMBOLS
*/
template < size_t T> struct SizeT {};
/**
* @endcond
*/
/** Error Type.
* Error type returned by the open of a PLY file.
*/
typedef enum NNP_ERROR
{
NNP_OK = 0x0000, /**< No error. */
NNP_UNABLE_TO_OPEN = 0x0001, /**< The file cannot be opend. */
NNP_MISSING_HEADER = 0x0002, /**< The file does not contain a valid PLY header. */
NNP_MISSING_FORMAT = 0x0004 /**< The file has an invalid internal format. */
} ErrorCode;
/** PLY Entity.
* Property that can be saved in a PLY file.
*/
typedef enum NNP_ENTITY
{
NNP_UNKNOWN_ENTITY = 0x0000, /**< Unknown property. */
NNP_PX = 0x0001, /**< Position x cordinate. */
NNP_PY = 0x0002, /**< Position y cordinate. */
NNP_PZ = 0x0004, /**< Position z cordinate. */
NNP_PXYZ = 0x0007, /**< Position (x, y, z). */
NNP_NX = 0x0010, /**< Normal x component. */
NNP_NY = 0x0020, /**< Normal y component. */
NNP_NZ = 0x0040, /**< Normal z component. */
NNP_NXYZ = 0x0070, /**< Normal (x, y, z). */
NNP_CR = 0x0100, /**< Color red component. */
NNP_CG = 0x0200, /**< Color green component. */
NNP_CB = 0x0400, /**< Color blue component. */
NNP_CRGB = 0x0700, /**< Color RGB. */
NNP_CA = 0x0800, /**< Color alpha component. */
NNP_CRGBA = 0x0F00, /**< Color RGBA. */
NNP_DENSITY = 0x1000, /**< Density or Radius property. */
NNP_SCALE = 0x2000, /**< Scale property. */
NNP_QUALITY = 0x4000, /**< Quality property. */
NNP_REFLECTANCE = 0x8000, /**< Refelctance property. */
NNP_BITFLAG = 0x10000, /**< Bit flags. */
NNP_VERTEX_LIST = 0x20000 /**< List of vertec index. */
} PlyEntity;
/** PLY Type.
* Type of a PLY property.
*/
typedef enum NNP_PLYTYPE
{
NNP_UNKNOWN_TYPE = 0x0000, /**< Unknown type. */
NNP_FLOAT32 = 0x0001, /**< Float. */
NNP_FLOAT64 = 0x0002, /**< Double. */
NNP_INT8 = 0x0010, /**< Char. */
NNP_INT16 = 0x0020, /**< Short. */
NNP_INT32 = 0x0040, /**< Int. */
NNP_UINT8 = 0x0100, /**< Unsigned Char. */
NNP_UINT16 = 0x0200, /**< Unsigned Short. */
NNP_UINT32 = 0x0400, /**< Unsigned Int. */
NNP_LIST_UINT8_UINT32 = 0x1000, /**< List (size Unsigned Char) of Unsigned Int. */
NNP_LIST_INT8_UINT32 = 0x2000, /**< List (size Char) of Unsigned Int. */
NNP_LIST_UINT8_INT32 = 0x4000, /**< List (size Unsigned Char) of Int. */
NNP_LIST_INT8_INT32 = 0x8000 /**< List (size Char) of Int. */
} PlyType;
/** PLY Property.
* Define a PLY property (entity and type).
*/
class PlyProperty
{
public:
PlyType type; /**< Property type. */
PlyEntity elem; /**< Property entity. */
/**
* Constructor that sets the type and the entity of the PLY property.
*
* @param _t Property type.
* @param _e Property entity.
*/
PlyProperty(PlyType _t, PlyEntity _e):type(_t),elem(_e){}
/**
* Get the description string of the property entity.
*
* @return Description string of the property entity.
*/
const char* EntityStr();
/**
* Get the name of the property entity.
*
* @return Name of the property entity.
*/
const char* EntityName();
/**
* Get the description string of the property type.
*
* @return Description string of the property type.
*/
const char* TypeStr();
/**
* Get the size in byte of the property type.
*
* @return Size in byte of the property type.
*/
int TypeSize();
/**
* Skip the property in an Ascii file.
*
* @param *fp Pointer to the opened file.
* @return If successful returns true. Otherwise, it returns false.
*/
bool SkipAsciiPropertyInFile(FILE *fp);
/**
* Skip the property in a binary file.
*
* @param *fp Pointer to the opened file.
* @return If successful returns true. Otherwise, it returns false.
*/
bool SkipBinaryPropertyInFile(FILE *fp);
/**
* Write the property in the header of the PLY file.
*
* @param *fp Pointer to the file.
* @return If successful returns true. Otherwise, it returns false.
*/
bool WriteHeader(FILE *fp);
};
const char* PlyProperty::EntityStr()
{
switch (this->elem)
{
case NNP_UNKNOWN_ENTITY : return "NNP_UNKNOWN_ENTITY";
case NNP_PX : return "NNP_PX ";
case NNP_PY : return "NNP_PY ";
case NNP_PZ : return "NNP_PZ ";
case NNP_PXYZ : return "NNP_PXYZ ";
case NNP_NX : return "NNP_NX ";
case NNP_NY : return "NNP_NY ";
case NNP_NZ : return "NNP_NZ ";
case NNP_NXYZ : return "NNP_NXYZ ";
case NNP_CR : return "NNP_CR ";
case NNP_CG : return "NNP_CG ";
case NNP_CB : return "NNP_CB ";
case NNP_CRGB : return "NNP_CRGB ";
case NNP_CA : return "NNP_CA ";
case NNP_CRGBA : return "NNP_CRGBA ";
case NNP_DENSITY : return "NNP_DENSITY ";
case NNP_SCALE : return "NNP_SCALE ";
case NNP_QUALITY : return "NNP_QUALITY ";
case NNP_REFLECTANCE : return "NNP_REFLECTANCE ";
case NNP_VERTEX_LIST : return "NNP_VERTEX_LIST ";
default: assert(0);
break;
}
return 0;
}
const char* PlyProperty::EntityName()
{
#ifdef USE_H4D_OUTPUT
switch (this->elem)
{
case NNP_UNKNOWN_ENTITY : return "unknown";
case NNP_PX : return "x";
case NNP_PY : return "y";
case NNP_PZ : return "z";
case NNP_PXYZ : return "x y z";
case NNP_NX : return "nx";
case NNP_NY : return "ny";
case NNP_NZ : return "nz";
case NNP_NXYZ : return "nx ny nz";
case NNP_CR : return "red";
case NNP_CG : return "green";
case NNP_CB : return "blue";
case NNP_CRGB : return "rgb";
case NNP_CA : return "alpha";
case NNP_CRGBA : return "rgba";
case NNP_DENSITY : return "radius";
case NNP_SCALE : return "scale";
case NNP_QUALITY : return "quality";
case NNP_REFLECTANCE : return "reflectance";
case NNP_VERTEX_LIST : return "vertex_indices";
default: assert(0);
break;
}
#else
switch (this->elem)
{
case NNP_UNKNOWN_ENTITY : return "unknown";
case NNP_PX : return "x";
case NNP_PY : return "y";
case NNP_PZ : return "z";
case NNP_PXYZ : return "x y z";
case NNP_NX : return "nx";
case NNP_NY : return "ny";
case NNP_NZ : return "nz";
case NNP_NXYZ : return "nx ny nz";
case NNP_CR : return "diffuse_red";
case NNP_CG : return "diffuse_green";
case NNP_CB : return "diffuse_blue";
case NNP_CRGB : return "diffuse_rgb";
case NNP_CA : return "alpha";
case NNP_CRGBA : return "diffuse_rgba";
case NNP_DENSITY : return "radius";
case NNP_SCALE : return "value";
case NNP_QUALITY : return "confidence";
case NNP_REFLECTANCE : return "reflectance";
case NNP_VERTEX_LIST : return "vertex_indices";
default: assert(0);
break;
}
#endif
return 0;
}
const char* PlyProperty::TypeStr()
{
switch (this->type)
{
case NNP_UNKNOWN_TYPE : return "NNP_UNKNOWN_TYPE ";
case NNP_FLOAT32 : return "NNP_FLOAT32 ";
case NNP_FLOAT64 : return "NNP_FLOAT64 ";
case NNP_INT8 : return "NNP_INT8 ";
case NNP_INT16 : return "NNP_INT16 ";
case NNP_INT32 : return "NNP_INT32 ";
case NNP_UINT8 : return "NNP_UINT8 ";
case NNP_UINT16 : return "NNP_UINT16 ";
case NNP_UINT32 : return "NNP_UINT32 ";
case NNP_LIST_UINT8_UINT32: return "NNP_LIST_UINT8_UINT32";
case NNP_LIST_INT8_UINT32 : return "NNP_LIST_INT8_UINT32 ";
case NNP_LIST_UINT8_INT32 : return "NNP_LIST_UINT8_INT32 ";
case NNP_LIST_INT8_INT32 : return "NNP_LIST_INT8_INT32 ";
default: assert(0);
break;
}
return 0;
}
int PlyProperty::TypeSize()
{
switch (this->type)
{
case NNP_UNKNOWN_TYPE:
return 0;
case NNP_INT8:
case NNP_UINT8:
return 1;
case NNP_INT16:
case NNP_UINT16:
return 2;
case NNP_FLOAT32:
case NNP_INT32:
case NNP_UINT32:
return 4;
case NNP_FLOAT64:
return 8;
case NNP_LIST_UINT8_UINT32:
case NNP_LIST_INT8_UINT32 :
case NNP_LIST_UINT8_INT32 :
case NNP_LIST_INT8_INT32 :
return 1;
default: assert(0);
break;
}
return 0;
}
bool PlyProperty::SkipAsciiPropertyInFile(FILE *fp)
{
int count = 1;
if (this->elem == NNP_CRGB || this->elem == NNP_NXYZ || this->elem == NNP_PXYZ)
count = 3;
else if (this->elem == NNP_CRGBA)
count = 4;
switch(type)
{
case NNP_INT8:
case NNP_INT16:
case NNP_INT32:
{
int* temp = new int[count];
for (int i = 0; i < count ; i++)
fscanf(fp, "%d", &temp[i]);
delete[] temp;
break;
}
case NNP_UINT8:
case NNP_UINT16:
case NNP_UINT32:
{
unsigned int* temp = new unsigned int[count];
for (int i = 0; i < count ; i++)
fscanf(fp, "%u", &temp[i]);
delete[] temp;
break;
}
case NNP_FLOAT32:
{
float* temp = new float[count];
for (int i = 0; i < count ; i++)
fscanf(fp, "%f", &temp[i]);
delete[] temp;
break;
}
case NNP_FLOAT64:
{
double* temp = new double[count];
for (int i = 0; i < count ; i++)
fscanf(fp, "%f", &temp[i]);
delete[] temp;
break;
}
case NNP_LIST_UINT8_UINT32:
case NNP_LIST_INT8_UINT32 :
{
fscanf(fp, "%d", &count);
unsigned int* temp = new unsigned int[count];
for (int i = 0; i < count ; i++)
fscanf(fp, "%u", &temp[i]);
delete[] temp;
break;
}
case NNP_LIST_UINT8_INT32 :
case NNP_LIST_INT8_INT32 :
{
fscanf(fp, "%d", &count);
int* temp = new int[count];
for (int i = 0; i < count ; i++)
fscanf(fp, "%d", &temp[i]);
delete[] temp;
break;
}
}
return true;
}
bool PlyProperty::SkipBinaryPropertyInFile(FILE *fp)
{
int count = 1;
if (this->elem == NNP_CRGB || this->elem == NNP_NXYZ || this->elem == NNP_PXYZ)
count = 3;
else if (this->elem == NNP_CRGBA)
count = 4;
if (this->type >= NNP_LIST_UINT8_UINT32)
{
unsigned char cntList = 0;
fread(&cntList, sizeof(char), 1, fp);
fseek(fp, 4 * cntList, SEEK_CUR);
}
else
fseek(fp, this->TypeSize() * count, SEEK_CUR);
return true;
}
bool PlyProperty::WriteHeader(FILE *fp)
{
std::string name, type;
switch (this->type)
{
case NNP_UNKNOWN_TYPE : type = "unknonw"; break;
case NNP_FLOAT32 : type = "float"; break;
case NNP_FLOAT64 : type = "double"; break;
case NNP_INT8 : type = "char"; break;
case NNP_INT16 : type = "short"; break;
case NNP_INT32 : type = "int"; break;
case NNP_UINT8 : type = "uchar"; break;
case NNP_UINT16 : type = "ushort"; break;
case NNP_UINT32 : type = "uint"; break;
case NNP_LIST_UINT8_UINT32: type = "list uchar uint"; break;
case NNP_LIST_INT8_UINT32 : type = "list char uint"; break;
case NNP_LIST_UINT8_INT32 : type = "list uchar int"; break;
case NNP_LIST_INT8_INT32 : type = "list char int"; break;
}
name = this->EntityName();
switch (this->elem)
{
case NNP_PXYZ :
{
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_PX).EntityName();
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_PY).EntityName();
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_PZ).EntityName();
break;
}
case NNP_NXYZ :
{
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_NX).EntityName();
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_NY).EntityName();
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_NZ).EntityName();
break;
}
case NNP_CRGB :
{
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_CR).EntityName();
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_CG).EntityName();
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_CB).EntityName();
break;
}
case NNP_CRGBA:
{
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_CR).EntityName();
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_CG).EntityName();
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_CB).EntityName();
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
name = PlyProperty(nanoply::NNP_FLOAT32, nanoply::NNP_CA).EntityName();;
break;
}
}
fprintf(fp, "property %s %s\n", type.c_str(), name.c_str());
return true;
}
/** PLY Element.
* Define a PLY Element as a collection of properties.
*/
class PlyElement
{
public:
std::string name; /**< Name of the elment in the PLY header (for example "vertex" or "face") */
int cnt; /**< Number of instances of the elment in the PLY file */
std::vector<PlyProperty> propVec; /**< Collection of properties that define the element */
/**
* Default Constructor
*/
PlyElement();
/**
* Constructor that sets the name, the properties and the number of instances of the element.
*
* @param *name Name of the element.
* @param &prop Vector of properties.
* @param nElem Number of instances.
*/
PlyElement(const char *name, std::vector<PlyProperty> &prop, int nElem);
/**
* Parse the input line and add the properties to the element.
* It assumes that the passed line has the folowing structure: "property PLYTYPE PLYELEMENT"
*
* @param *line Input line.
* @return If successful returns true. Otherwise, it returns false.
*/
bool AddProperty(const char *line);
/**
* Initialize an element from an header file.
* The first line of the buf is passed into line and must start with the 'element' keyword
*
* @param *fp Pointer to the opened file.
* @param *line First buffer line.
* @return If successful returns true. Otherwise, it returns false.
*/
bool InitFromHeader(FILE *fp, char *line);
/**
* Write the element descriport in the header file.
*
* @param *fp Pointer to the file.
* @return If successful returns true. Otherwise, it returns false.
*/
bool WriteHeader(FILE *fp);
/**
* Skip the element in an Ascii file.
*
* @param *fp Pointer to the opened file.
* @return If successful returns true. Otherwise, it returns false.
*/
bool SkipAsciiElementsInFile(FILE *fp);
/**
* Skip the element in a binary file.
*
* @param *fp Pointer to the opened file.
* @return If successful returns true. Otherwise, it returns false.
*/
bool SkipBinaryElementsInFile(FILE *fp);
/**
* Check if the input entity is in the property of the element.
*
* @param entity Input entity.
* @return If successful returns true. Otherwise, it returns false.
*/
bool Contains(NNP_ENTITY entity);
};
PlyElement::PlyElement(){}
PlyElement::PlyElement(const char *_name, std::vector<PlyProperty> &prop, int nElem):name(_name), cnt(nElem), propVec(prop)
{
}
bool PlyElement::InitFromHeader(FILE *fp, char *line)
{
char buf[4096];
for(int i=0;line[i]!=0;++i) buf[i]=tolower(line[i]);
strtok(buf," \t"); // property
assert(strstr(buf,"element"));
char *el = strtok(0," \t\n");
name = std::string(el);
sscanf(line,"%*s %*s %i",&cnt);
//printf("Adding Element '%s' (%i) \n",name.c_str(),cnt);
fgets(line,4096,fp);
while(strstr(line,"property"))
{
AddProperty(line);
fgets(line,4096,fp);
}
unsigned int mask = 0;
for (int i = 0; i < propVec.size(); i++)
mask |= propVec[i].elem;
std::vector<PlyProperty> compactPropVec;
for (int i = 0; i < propVec.size(); i++)
{
switch (propVec[i].elem)
{
case NNP_NX:
case NNP_NY:
if ((mask & NNP_NXYZ) != NNP_NXYZ)
compactPropVec.push_back(propVec[i]);
break;
case NNP_NZ:
if ((mask & NNP_NXYZ) != NNP_NXYZ)
compactPropVec.push_back(propVec[i]);
else
compactPropVec.push_back(PlyProperty(propVec[i].type, NNP_NXYZ));
break;
case NNP_PX:
case NNP_PY:
if ((mask & NNP_PXYZ) != NNP_PXYZ)
compactPropVec.push_back(propVec[i]);
break;
case NNP_PZ:
if ((mask & NNP_PXYZ) != NNP_PXYZ)
compactPropVec.push_back(propVec[i]);
else
compactPropVec.push_back(PlyProperty(propVec[i].type, NNP_PXYZ));
break;
case NNP_CR:
case NNP_CG:
if ((mask & NNP_CRGB) != NNP_CRGB & (mask & NNP_CRGBA) != NNP_CRGBA)
compactPropVec.push_back(propVec[i]);
break;
case NNP_CB:
if ((mask & NNP_CRGB) != NNP_CRGB & (mask & NNP_CRGBA) != NNP_CRGBA)
compactPropVec.push_back(propVec[i]);
else if ((mask & NNP_CRGB) == NNP_CRGB & (mask & NNP_CRGBA) != NNP_CRGBA)
compactPropVec.push_back(PlyProperty(propVec[i].type, NNP_CRGB));
break;
case NNP_CA:
if ((mask & NNP_CRGB) != NNP_CRGB & (mask & NNP_CRGBA) != NNP_CRGBA)
compactPropVec.push_back(propVec[i]);
else if ((mask & NNP_CRGBA) == NNP_CRGBA)
compactPropVec.push_back(PlyProperty(propVec[i].type, NNP_CRGBA));
break;
default:
compactPropVec.push_back(propVec[i]);
break;
}
}
propVec.clear();
propVec = compactPropVec;
return true;
}
bool PlyElement::WriteHeader(FILE *fp)
{
fprintf(fp, "element %s %d\n", name.c_str(), cnt);
for(int i = 0; i < propVec.size(); i++)
propVec[i].WriteHeader(fp);
return true;
}
bool PlyElement::SkipAsciiElementsInFile(FILE *fp)
{
char line[4096];
for(int i = 0; i < this->cnt; ++i)
fgets(line, 4096, fp);
return true;
}
bool PlyElement::SkipBinaryElementsInFile(FILE *fp)
{
for(int i = 0; i < this->cnt; ++i)
for(int j = 0; j < this->propVec.size(); ++j)
this->propVec[j].SkipBinaryPropertyInFile(fp);
return true;
}
bool PlyElement::AddProperty(const char *line)
{
char buf[128];
for(int i=0;line[i]!=0;++i) buf[i]=tolower(line[i]);
strtok(buf," \t"); // property
char *ty = strtok(0," \t\n"); // float
PlyType type = NNP_UNKNOWN_TYPE;
if(strcmp(ty,"float") == 0 || strcmp(ty,"float32") == 0) type = NNP_FLOAT32;
if(strcmp(ty,"double") == 0 || strcmp(ty,"float64") == 0) type = NNP_FLOAT64;
if(strcmp(ty,"char") == 0 || strcmp(ty,"int8") == 0) type = NNP_INT8;
if(strcmp(ty,"short") == 0 || strcmp(ty,"int16") == 0) type = NNP_INT16;
if(strcmp(ty,"int") == 0 || strcmp(ty,"int32") == 0) type = NNP_INT32;
if(strcmp(ty,"uchar") == 0 || strcmp(ty,"uint8") == 0 ) type = NNP_UINT8;
if(strcmp(ty,"ushort") == 0|| strcmp(ty,"uint16") == 0 ) type = NNP_UINT16;
if(strcmp(ty,"uint") == 0 || strcmp(ty,"uint32") == 0 ) type = NNP_UINT32;
if(strcmp(ty,"list") == 0 ) {
char *ty1 = strtok(0," \t\n");
char *ty2 = strtok(0," \t\n");
if( (strcmp(ty1,"uchar") == 0 ||strcmp(ty1,"uint8") == 0 ) && (strcmp(ty2,"uint") == 0 || strcmp(ty2,"uint32") == 0) )
type = NNP_LIST_UINT8_UINT32;
if( (strcmp(ty1,"char") == 0 || strcmp(ty1,"int8") == 0) && (strcmp(ty2,"uint") == 0|| strcmp(ty2,"uint32") == 0) )
type = NNP_LIST_INT8_UINT32;
if( (strcmp(ty1,"uchar") == 0 ||strcmp(ty1,"uint8") == 0) && (strcmp(ty2,"int") == 0 || strcmp(ty2,"int32") == 0) )
type = NNP_LIST_UINT8_INT32;
if( (strcmp(ty1,"char") == 0 || strcmp(ty1,"int8") == 0) && (strcmp(ty2,"int") == 0 || strcmp(ty2,"int32") ) )
type = NNP_LIST_INT8_INT32;
}
assert(type != NNP_UNKNOWN_TYPE);
char *el = strtok(0," \t\n"); // x
PlyEntity ent = NNP_UNKNOWN_ENTITY;
if(strstr(el,"x")) ent = NNP_PX;
if(strstr(el,"y")) ent = NNP_PY;
if(strstr(el,"z")) ent = NNP_PZ;
if(strstr(el,"nx")) ent = NNP_NX;
if(strstr(el,"ny")) ent = NNP_NY;
if(strstr(el,"nz")) ent = NNP_NZ;
if (strstr(el,"red")) ent = NNP_CR;
if (strstr(el,"diffuse_red")) ent = NNP_CR;
if (strstr(el,"green")) ent = NNP_CG;
if (strstr(el,"diffuse_green")) ent = NNP_CG;
if (strstr(el,"blue")) ent = NNP_CB;
if (strstr(el,"diffuse_blue")) ent = NNP_CB;
if(strstr(el,"alpha")) ent = NNP_CA;
if (strstr(el,"scale")) ent = NNP_SCALE;
if (strstr(el,"value")) ent = NNP_SCALE;
if(strstr(el,"density")) ent = NNP_DENSITY;
if(strstr(el,"radius")) ent = NNP_DENSITY;
if (strstr(el,"quality")) ent = NNP_QUALITY;
if (strstr(el,"confidence")) ent = NNP_QUALITY;
if(strstr(el,"reflectance")) ent = NNP_REFLECTANCE;
if(strstr(el,"vertex_index")) ent = NNP_VERTEX_LIST;
if(strstr(el,"vertex_indices")) ent = NNP_VERTEX_LIST;
//assert(ent != NNP_UNKNOWN_ENTITY);
propVec.push_back(PlyProperty(type,ent));
//printf("Adding Property %s %s\n",propVec.back().TypeStr(),propVec.back().EntityStr());
return true;
}
bool PlyElement::Contains(PlyEntity entity)
{
for (int i = 0; i < propVec.size(); i++)
{
if (propVec[i].elem == entity)
return true;
}
return false;
}
/** PLY header info.
* Define the data of the PLY header
*/
class Info
{
public:
ErrorCode errInfo; /**< Error code returned by the reading of a PLY file */
bool binary; /**< Boolean about the file format (Binary = true, Ascci = false) */
std::vector<PlyElement> elemVec; /**< Elements defided in the header */
bool bigEndian; /**< Endianess of the binary file */
/**
* Default Constructor
*/
Info();
/**
* Constructor that reads the header info from a file.
*
* @param *filename Path of the file to read.
*/
Info(const char *filename);
/**
* Constructor that creates the header info for a mesh.
*
* @param &vertex Vertex element object.
* @param &face Face element object.
* @param binary File format (binary = true, ascci = false).
*/
Info(PlyElement &vertex, PlyElement &face, bool binary);
/**
* Constructor that creates the header info for a point cloud.
*
* @param &vertex Vertex element object.
* @param binary File format (binary = true, ascci = false).
*/
Info(PlyElement &vertex, bool binary);
/**
* Clear the object.
*/
void Clear() { errInfo=NNP_OK; }
/**
* Return the number of vertex instances
*
* @return The number of vertex instances
*/
int GetVertexCount() const;
/**
* Return the number of face instances
*
* @return The number of face instances
*/
int GetFaceCount() const;
/**
* Return a reference to the vertex element
*
* @return The reference to the vertex element
*/
PlyElement* GetVertexElement();
/**
* Return a reference to the face element
*
* @return The reference to the face element
*/
PlyElement* GetFaceElement();
};
Info::Info(){}
Info::Info(const char *filename)
{
this->errInfo = NNP_OK;
FILE *fp=fopen(filename,"r");
if(!fp)
{
this->errInfo = NNP_UNABLE_TO_OPEN;
return;
}
char buf[4096];
fgets(buf,4096,fp);
if( (strncmp(buf,"PLY",3)!=0) && (strncmp(buf,"ply",3)!=0) )
{
this->errInfo = NNP_MISSING_HEADER;
return;
}
fgets(buf,4096,fp);
if(strncmp(buf,"format",strlen("format"))!=0)
{
this->errInfo = NNP_MISSING_FORMAT;
return;
}
if(strstr(buf,"ascii") || strstr(buf,"ASCII"))
{
this->binary=false;
}
else if(strstr(buf,"binary") || strstr(buf,"BINARY"))
{
this->binary=true;
if (strstr(buf, "binary_big") || strstr(buf, "BINARY_BIG"))
this->bigEndian = true;
else
this->bigEndian = false;
}
else
{
this->errInfo = NNP_MISSING_FORMAT;
return;
}
fgets(buf,4096,fp);
while(strncmp(buf,"end_header",strlen("end_header")))
{
if(strstr(buf,"comment") || strstr(buf,"COMMENT") )
{
fgets(buf,4096,fp);
continue;
}
if(strstr(buf,"element"))
{
PlyElement pe;
pe.InitFromHeader(fp,buf);
this->elemVec.push_back(pe);
}
}
fclose(fp);
}
Info::Info(PlyElement &vertex, PlyElement &face, bool binary)
{
elemVec.push_back(vertex);
elemVec.push_back(face);
this->binary = binary;
}
Info::Info(PlyElement &vertex, bool binary)
{
elemVec.push_back(vertex);
this->binary = binary;
}
int Info::GetVertexCount() const
{
for (int i = 0; i < elemVec.size(); i++)
{
if (elemVec[i].name.compare(std::string("vertex")) == 0)
return elemVec[i].cnt;
}
return -1;
}
int Info::GetFaceCount() const
{
for (int i = 0; i < elemVec.size(); i++)
{
if (elemVec[i].name.compare(std::string("face")) == 0)
return elemVec[i].cnt;
}
return -1;
}
PlyElement* Info::GetVertexElement()
{
for (int i = 0; i < elemVec.size(); i++)
{
if (elemVec[i].name.compare(std::string("vertex")) == 0)
return &elemVec[i];
}
return NULL;
}
PlyElement* Info::GetFaceElement()
{
for (int i = 0; i < elemVec.size(); i++)
{
if (elemVec[i].name.compare(std::string("face")) == 0)
return &elemVec[i];
}
return NULL;
}
/**
* @cond HIDDEN_SYMBOLS
*/
void adjustEndianess(unsigned char* buffer, int typeSize, int count)
{
for (int i = 0; i < count; i++)
{
int offset = i*typeSize;
for (int j = 0; j < typeSize/2; j++)
{
unsigned char temp = buffer[offset+j];
buffer[offset+j] = buffer[offset + typeSize - 1 - j];
buffer[offset + typeSize - 1 - j] = temp;
}
}
}
/**
* @endcond
*/
/** Memory descriptor of a vector of properties.
* The class defines how a vector of PlyProperty is saved in memory.
*
* @tparam CointainerType Type of the container of the property
* @tparam VectorSize Number of values stored in the property.
* @tparam ScalarType Type of the values stored in the property.
*/
template<class CointainerType, int VectorSize, typename ScalarType>
class VectorDescriptor
{
int64_t curPos; /**< Position of the next property to read or to write. */
PlyEntity elem; /**< Ply entity managed by the descriptor. */
void *base; /**< Pointer to the memory location that contains the data of the property. */
public:
/**
* Void constructor.
*
*/
VectorDescriptor();
/**
* Constructor of the descriptor.
*
* @param _e Ply entity managed by the descriptor.
* @param *_b Pointer to the memory location that contains the data of the property.
*/
VectorDescriptor(PlyEntity _e, void *_b);
/**
* Restart the descriptor.
*/
void Restart();
/**
* Read the property data from the binary file if the entity of the property prop is equals to the entity of the descriptor.
*
* @param *fp Pointer to the opened file.
* @param &prop Next PLY property to read from the file.
* @param bigEndian Endianess of the binary data (true = big endian, false = little endian).
* @return If successful returns true. Otherwise, it returns false.
*/
bool ReadElemBinary(FILE *fp, PlyProperty &prop, bool bigEndian);
/**
* Read the property data from the ascii file if the entity of the property prop is equals to the entity of the descriptor.
*
* @param *fp Pointer to the opened file.
* @param &prop Next PLY property to read from the file.
* @return If successful returns true. Otherwise, it returns false.
*/
bool ReadElemAscii(FILE *fp, PlyProperty &prop);
/**
* Write the property data in the binary file if the entity of the property prop is equals to the entity of the descriptor.
*
* @param *fp Pointer to the file.
* @param &prop Next PLY property to write from the file.
* @return If successful returns true. Otherwise, it returns false.
*/
bool WriteElemBinary(FILE *fp, PlyProperty &prop);
/**
* Write the property data in the ascii file if the entity of the property prop is equals to the entity of the descriptor.
*
* @param *fp Pointer to the file.
* @param &prop Next PLY property to write from the file.
* @return If successful returns true. Otherwise, it returns false.
*/
bool WriteElemAscii(FILE *fp, PlyProperty &prop);
private:
template<typename C>
void ReadBinary(FILE *fp, PlyProperty &prop, bool bigEndian);
template<typename C>
void ReadAscii(FILE *fp, PlyProperty &prop, const char *format);
template<typename C>
void WriteBinary(FILE *fp, PlyProperty &prop);
template<typename C>
void WriteAscii(FILE *fp, PlyProperty &prop, const char *format);
};
template<class CointainerType, int VectorSize, typename ScalarType>
VectorDescriptor<CointainerType, VectorSize, ScalarType>::VectorDescriptor()
{
}
template<class CointainerType, int VectorSize, typename ScalarType>
VectorDescriptor<CointainerType, VectorSize, ScalarType>::VectorDescriptor(PlyEntity _e, void *_b):curPos(0),elem(_e),base(_b)
{
}
template<class CointainerType, int VectorSize, typename ScalarType>
void VectorDescriptor<CointainerType, VectorSize, ScalarType>::Restart()
{
this->curPos=0;
}
template<class ContainerType, int VectorSize, typename ScalarType>
template<typename C>
void VectorDescriptor<ContainerType, VectorSize, ScalarType>::ReadBinary(FILE *fp, PlyProperty &prop, bool bigEndian)
{
int count = 1;
if (prop.elem == NNP_CRGB || prop.elem == NNP_NXYZ || prop.elem == NNP_PXYZ)
count = 3;
else if (prop.elem == NNP_CRGBA)
count = 4;
int typeSize = prop.TypeSize();
unsigned char* buffer = new unsigned char[count*typeSize];
fread(buffer, typeSize, count, fp);
if (typeSize > 1 && bigEndian)
adjustEndianess(buffer, typeSize, count);
if (prop.type == NNP_LIST_UINT8_UINT32 || prop.type == NNP_LIST_UINT8_INT32)
{
count = buffer[0];
delete[] buffer;
buffer = new unsigned char[count*4];
fread(buffer, 4, count, fp);
if (bigEndian)
adjustEndianess(buffer, 4, count);
}
else if (prop.type == NNP_LIST_INT8_UINT32 || prop.type == NNP_LIST_INT8_INT32)
{
count = char(buffer[0]);
delete[] buffer;
buffer = new unsigned char[count*4];
fread(buffer, 4, count, fp);
if (bigEndian)
adjustEndianess(buffer, 4, count);
}
C* temp = (C*)buffer;
unsigned char* baseProp = (unsigned char*)base + this->curPos*sizeof(ContainerType);
for (int i = 0; i < std::min(VectorSize, count); i++)
*(ScalarType *)(baseProp + i*sizeof(ScalarType)) = ScalarType(temp[i]);
++(this->curPos);
delete[] buffer;
}
template<class ContainerType, int VectorSize, typename ScalarType>
bool VectorDescriptor<ContainerType, VectorSize, ScalarType>::ReadElemBinary(FILE *fp, PlyProperty &prop, bool bigEndian)
{
if (prop.elem != elem)
return false;
switch(prop.type)
{
case NNP_INT8: this->ReadBinary<char>(fp, prop, bigEndian); break;
case NNP_UINT8: this->ReadBinary<unsigned char>(fp, prop, bigEndian); break;
case NNP_INT16: this->ReadBinary<short>(fp, prop, bigEndian); break;
case NNP_UINT16: this->ReadBinary<unsigned short>(fp, prop, bigEndian); break;
case NNP_FLOAT32: this->ReadBinary<float>(fp, prop, bigEndian); break;
case NNP_INT32: this->ReadBinary<int>(fp, prop, bigEndian); break;
case NNP_UINT32: this->ReadBinary<unsigned int>(fp, prop, bigEndian); break;
case NNP_FLOAT64: this->ReadBinary<double>(fp, prop, bigEndian); break;
case NNP_LIST_UINT8_UINT32:
case NNP_LIST_INT8_UINT32: this->ReadBinary<unsigned int>(fp, prop, bigEndian); break;
case NNP_LIST_UINT8_INT32:
case NNP_LIST_INT8_INT32: this->ReadBinary<int>(fp, prop, bigEndian); break;
}
return true;
}
template<class ContainerType, int VectorSize, typename ScalarType>
template<typename C>
void VectorDescriptor<ContainerType, VectorSize, ScalarType>::ReadAscii(FILE *fp, PlyProperty &prop, const char *format)
{
int count = 1;
if (prop.elem == NNP_CRGB || prop.elem == NNP_NXYZ || prop.elem == NNP_PXYZ)
count = 3;
else if (prop.elem == NNP_CRGBA)
count = 4;
if (prop.type == NNP_LIST_UINT8_UINT32 || prop.type == NNP_LIST_UINT8_INT32)
{
unsigned char listSize;
fscanf(fp, "%u", &listSize);
count = listSize;
}
else if (prop.type == NNP_LIST_INT8_UINT32 || prop.type == NNP_LIST_INT8_INT32)
{
char listSize;
fscanf(fp, "%d", &listSize);
count = listSize;
}
C* temp = new C[count];
for (int i = 0; i < count ; i++)
fscanf(fp, format, &temp[i]);
unsigned char* baseProp = (unsigned char*)base + this->curPos*sizeof(ContainerType);
for (int i = 0; i < std::min(VectorSize,count); i++)
*(ScalarType *)(baseProp + i*sizeof(ScalarType)) = ScalarType(temp[i]);
delete[] temp;
++(this->curPos);
}
template<class ContainerType, int VectorSize, typename ScalarType>
bool VectorDescriptor<ContainerType, VectorSize, ScalarType>::ReadElemAscii(FILE *fp, PlyProperty &prop)
{
if (prop.elem != elem)
return false;
switch(prop.type)
{
case NNP_INT8: this->ReadAscii<int>(fp, prop, "%d"); break;
case NNP_UINT8: this->ReadAscii<unsigned int>(fp, prop, "%u"); break;
case NNP_INT16: this->ReadAscii<short>(fp, prop, "%d"); break;
case NNP_UINT16: this->ReadAscii<unsigned short>(fp, prop, "%u"); break;
case NNP_FLOAT32: this->ReadAscii<float>(fp, prop, "%f"); break;
case NNP_INT32: this->ReadAscii<int>(fp, prop, "%d"); break;
case NNP_UINT32: this->ReadAscii<unsigned int>(fp, prop, "%u"); break;
case NNP_FLOAT64: this->ReadAscii<double>(fp, prop, "%f"); break;
case NNP_LIST_UINT8_UINT32:
case NNP_LIST_INT8_UINT32: this->ReadAscii<unsigned int>(fp, prop, "%u"); break;
case NNP_LIST_UINT8_INT32:
case NNP_LIST_INT8_INT32: this->ReadAscii<int>(fp, prop, "%d"); break;
}
return true;
}
template<class ContainerType, int VectorSize, typename ScalarType>
template<typename C>
void VectorDescriptor<ContainerType, VectorSize, ScalarType>::WriteBinary(FILE *fp, PlyProperty &prop)
{
int count = 1;
if (prop.elem == NNP_CRGB || prop.elem == NNP_NXYZ || prop.elem == NNP_PXYZ)
count = 3;
else if (prop.elem == NNP_CRGBA)
count = 4;
C data[VectorSize];
if (prop.type == NNP_LIST_UINT8_UINT32 || prop.type == NNP_LIST_UINT8_INT32)
{
unsigned char listSize = (unsigned char) VectorSize;
fwrite(&listSize, sizeof(unsigned char), 1, fp);
count = VectorSize;
}
else if (prop.type == NNP_LIST_INT8_UINT32 || prop.type == NNP_LIST_INT8_INT32)
{
char listSize = (char) VectorSize;
fwrite(&listSize, sizeof(char), 1, fp);
count = VectorSize;
}
C temp = 0;
unsigned char* baseProp = (unsigned char*)base + this->curPos*sizeof(ContainerType);
for (int i = 0; i < std::min(VectorSize, count); i++)
data[i] = (C)(*(ScalarType*)(baseProp + i*sizeof(ScalarType)));
fwrite(data, sizeof(C), std::min(VectorSize, count), fp);
for (int i = 0; i < (count - VectorSize); i++)
fwrite(&temp, sizeof(C), 1, fp);
++(this->curPos);
}
template<class ContainerType, int VectorSize, typename ScalarType>
bool VectorDescriptor<ContainerType, VectorSize, ScalarType>::WriteElemBinary(FILE *fp, PlyProperty &prop)
{
if (prop.elem != elem)
return false;
switch(prop.type)
{
case NNP_INT8: this->WriteBinary<char>(fp, prop); break;
case NNP_UINT8: this->WriteBinary<unsigned char>(fp, prop); break;
case NNP_INT16: this->WriteBinary<short>(fp, prop); break;
case NNP_UINT16: this->WriteBinary<unsigned short>(fp, prop); break;
case NNP_FLOAT32: this->WriteBinary<float>(fp, prop); break;
case NNP_INT32: this->WriteBinary<int>(fp, prop); break;
case NNP_UINT32: this->WriteBinary<unsigned int>(fp, prop); break;
case NNP_FLOAT64: this->WriteBinary<double>(fp, prop); break;
case NNP_LIST_UINT8_UINT32:
case NNP_LIST_INT8_UINT32: this->WriteBinary<unsigned int>(fp, prop); break;
case NNP_LIST_UINT8_INT32:
case NNP_LIST_INT8_INT32: this->WriteBinary<int>(fp, prop); break;
}
return true;
}
template<class ContainerType, int VectorSize, typename ScalarType>
template<typename C>
void VectorDescriptor<ContainerType, VectorSize, ScalarType>::WriteAscii(FILE *fp, PlyProperty &prop, const char *format)
{
int count = 1;
if (prop.elem == NNP_CRGB || prop.elem == NNP_NXYZ || prop.elem == NNP_PXYZ)
count = 3;
else if (prop.elem == NNP_CRGBA)
count = 4;
if (prop.type == NNP_LIST_UINT8_UINT32 || prop.type == NNP_LIST_UINT8_INT32)
{
fprintf(fp, "%u ", (unsigned char)(VectorSize));
count = VectorSize;
}
else if (prop.type == NNP_LIST_INT8_UINT32 || prop.type == NNP_LIST_INT8_INT32)
{
fprintf(fp, "%d ", (char)(VectorSize));
count = VectorSize;
}
unsigned char* baseProp = (unsigned char*)base + this->curPos*sizeof(ContainerType);
for (int i = 0; i < std::min(VectorSize, count); i++)
fprintf(fp, format, (C)(*(ScalarType*)(baseProp + i*sizeof(ScalarType))));
for (int i = 0; i < (count - VectorSize); i++)
fprintf(fp, format, (C)(0));
++(this->curPos);
}
template<class ContainerType, int VectorSize, typename ScalarType>
bool VectorDescriptor<ContainerType, VectorSize, ScalarType>::WriteElemAscii(FILE *fp, PlyProperty& prop)
{
if (prop.elem != elem)
return false;
switch(prop.type)
{
case NNP_INT8: this->WriteAscii<char>(fp, prop, "%d "); break;
case NNP_UINT8: this->WriteAscii<unsigned char>(fp, prop, "%u "); break;
case NNP_INT16: this->WriteAscii<short>(fp, prop, "%d "); break;
case NNP_UINT16: this->WriteAscii<unsigned short>(fp, prop, "%u "); break;
case NNP_FLOAT32: this->WriteAscii<float>(fp, prop, "%f "); break;
case NNP_INT32: this->WriteAscii<int>(fp, prop, "%d "); break;
case NNP_UINT32: this->WriteAscii<unsigned int>(fp, prop, "%u "); break;
case NNP_FLOAT64: this->WriteAscii<double>(fp, prop, "%f "); break;
case NNP_LIST_UINT8_UINT32:
case NNP_LIST_INT8_UINT32: this->WriteAscii<unsigned int>(fp, prop, "%u "); break;
case NNP_LIST_UINT8_INT32:
case NNP_LIST_INT8_INT32: this->WriteAscii<int>(fp, prop, "%d "); break;
}
return true;
}
/**
* @cond HIDDEN_SYMBOLS
*/
template <class TupleType>
void ReadBinaryElement(TupleType &adaptor, PlyElement &elem, FILE *fp, bool bigEndian)
{
for (int i = 0 ; i < elem.cnt; i++)
{
for (int j = 0; j < elem.propVec.size(); j++)
{
PlyProperty& prop = elem.propVec[j];
if (!TupleForEach(adaptor, fp, prop, bigEndian, SizeT<0>()))
prop.SkipBinaryPropertyInFile(fp);
}
}
}
template <class TupleType>
void ReadAsciiElement(TupleType &adaptor, PlyElement &elem, FILE *fp)
{
for (int i = 0 ; i < elem.cnt; i++)
{
for (int j = 0; j < elem.propVec.size(); j++)
{
PlyProperty& prop = elem.propVec[j];
if (!TupleForEach(adaptor, fp, prop, false, SizeT<1>()))
prop.SkipAsciiPropertyInFile(fp);
}
}
}
/**
* @endcond
*/
/**
* Read a point cloud from a PLY file.
*
* @tparam VertexAdaptorTuple Type that defines the management of the vertex data in memory
*
* @param filename Path to the file to read
* @param vertexAdaptor std::tuple that defines how to manage the vertex data in memory
*/
template <class VertexAdaptorTuple>
bool OpenPointCloud(const char *filename, VertexAdaptorTuple vertexAdaptor)
{
nanoply::Info info(filename);
if (info.errInfo != NNP_OK)
return false;
FILE *fp=fopen(filename,"rb");
if(!fp)
{
return false;
}
char buf[4096];
do
{
fgets(buf,4096,fp);
}
while(strncmp(buf,"end_header",strlen("end_header")) );
// Now start the real reading!
if (info.binary)
{
for(int i = 0; i < info.elemVec.size();++i)
if (strcmp(info.elemVec[i].name.c_str(), "vertex") == 0)
ReadBinaryElement<VertexAdaptorTuple>(vertexAdaptor, info.elemVec[i], fp, info.bigEndian);
else
info.elemVec[i].SkipBinaryElementsInFile(fp);
}
else
{
for(int i = 0; i < info.elemVec.size();++i)
if (strcmp(info.elemVec[i].name.c_str(), "vertex") == 0)
ReadAsciiElement<VertexAdaptorTuple>(vertexAdaptor, info.elemVec[i], fp);
else
info.elemVec[i].SkipAsciiElementsInFile(fp);
}
return true;
}
/**
* Read a mesh from a PLY file.
*
* @tparam VertexAdaptorTuple Type that defines the management of the vertex data in memory
* @tparam FaceAdaptorTuple Type that defines the management of the face data in memory
*
* @param filename Path to the file to read
* @param vertexAdaptor std::tuple that defines how to manage the vertex data in memory
* @param faceAdaptor std::tuple that defines how to manage the face data in memory
*/
template <class VertexAdaptorTuple, class FaceAdaptorTuple>
bool OpenMesh(const char *filename, VertexAdaptorTuple vertexAdaptor, FaceAdaptorTuple faceAdaptor)
{
nanoply::Info info(filename);
if (info.errInfo != NNP_OK)
return false;
FILE *fp=fopen(filename,"rb");
if(!fp)
{
return false;
}
char buf[4096];
do
{
fgets(buf,4096,fp);
}
while(strncmp(buf,"end_header",strlen("end_header")) );
// Now start the real reading!
if (info.binary)
{
for(int i = 0; i < info.elemVec.size();++i)
{
if (strcmp(info.elemVec[i].name.c_str(), "vertex") == 0)
ReadBinaryElement<VertexAdaptorTuple>(vertexAdaptor, info.elemVec[i], fp, info.bigEndian);
else if (strcmp(info.elemVec[i].name.c_str(), "face") == 0)
ReadBinaryElement<FaceAdaptorTuple>(faceAdaptor, info.elemVec[i], fp, info.bigEndian);
else
info.elemVec[i].SkipBinaryElementsInFile(fp);
}
}
else
{
for(int i = 0; i < info.elemVec.size();++i)
{
if (strcmp(info.elemVec[i].name.c_str(), "vertex") == 0)
ReadAsciiElement<VertexAdaptorTuple>(vertexAdaptor, info.elemVec[i], fp);
else if (strcmp(info.elemVec[i].name.c_str(), "face") == 0)
ReadAsciiElement<FaceAdaptorTuple>(faceAdaptor, info.elemVec[i], fp);
else
info.elemVec[i].SkipAsciiElementsInFile(fp);
}
}
}
/**
* @cond HIDDEN_SYMBOLS
*/
template <class TupleType>
void WriteBinaryElement(TupleType &adaptor, PlyElement &elem, FILE *fp)
{
for (int i = 0 ; i < elem.cnt; i++)
{
for (int j = 0; j < elem.propVec.size(); j++)
{
PlyProperty& prop = elem.propVec[j];
TupleForEach(adaptor, fp, prop, false, SizeT<2>());
}
}
}
template <class TupleType>
void WriteAsciiElement(TupleType &adaptor, PlyElement &elem, FILE *fp)
{
for (int i = 0 ; i < elem.cnt; i++)
{
for (int j = 0; j < elem.propVec.size(); j++)
{
PlyProperty& prop = elem.propVec[j];
TupleForEach(adaptor, fp, prop, false, SizeT<3>());
}
fprintf(fp, "\n");
}
}
/**
* @endcond
*/
/**
* Save a point cloud from a PLY file.
*
* @tparam VertexAdaptorTuple Type that defines the management of the vertex data in memory
*
* @param filename Path to the file to save
* @param vertexAdaptor std::tuple that defines how to manage the vertex data in memory
* @param info Info to saved in the PLY header
*/
template <class VertexAdaptorTuple>
bool SavePointCloud(const char *filename, VertexAdaptorTuple vertexAdaptor, nanoply::Info &info)
{
FILE *fp=fopen(filename,"wb");
if(!fp)
{
return false;
}
fprintf(fp, "ply\n");
if (info.binary)
fprintf(fp, "format binary_little_endian 1.0\n");
else
fprintf(fp, "format ascii 1.0\n");
for (int i = 0; i < info.elemVec.size(); i++)
{
if (strcmp(info.elemVec[i].name.c_str(), "vertex") != 0)
{
info.elemVec[i].cnt = 0;
info.elemVec[i].WriteHeader(fp);
}
else
info.elemVec[i].WriteHeader(fp);
}
fprintf(fp, "end_header\n");
if (info.binary)
{
for(int i = 0; i < info.elemVec.size();++i)
if (strcmp(info.elemVec[i].name.c_str(), "vertex") == 0)
WriteBinaryElement<VertexAdaptorTuple>(vertexAdaptor, info.elemVec[i], fp);
}
else
{
for(int i = 0; i < info.elemVec.size();++i)
if (strcmp(info.elemVec[i].name.c_str(), "vertex") == 0)
WriteAsciiElement<VertexAdaptorTuple>(vertexAdaptor, info.elemVec[i], fp);
}
fclose(fp);
return true;
}
/**
* Save a mesh from a PLY file.
*
* @tparam VertexAdaptorTuple Type that defines the management of the vertex data in memory
* @tparam FaceAdaptorTuple Type that defines the management of the face data in memory
*
* @param filename Path to the file to save
* @param vertexAdaptor std::tuple that defines how to manage the vertex data in memory
* @param faceAdaptor std::tuple that defines how to manage the face data in memory
* @param info Info to saved in the PLY header
*/
template <class VertexAdaptorTuple, class FaceAdaptorTuple>
bool SaveMesh(const char *filename, VertexAdaptorTuple vertexAdaptor, FaceAdaptorTuple faceAdaptor, nanoply::Info &info)
{
FILE *fp=fopen(filename,"wb");
if(!fp)
{
return false;
}
fprintf(fp, "ply\n");
if (info.binary)
fprintf(fp, "format binary_little_endian 1.0\n");
else
fprintf(fp, "format ascii 1.0\n");
for (int i = 0; i < info.elemVec.size(); i++)
{
if (strcmp(info.elemVec[i].name.c_str(), "vertex") != 0 && strcmp(info.elemVec[i].name.c_str(), "face") != 0)
{
info.elemVec[i].cnt = 0;
info.elemVec[i].WriteHeader(fp);
}
else
info.elemVec[i].WriteHeader(fp);
}
fprintf(fp, "end_header\n");
if (info.binary)
{
for(int i = 0; i < info.elemVec.size();++i)
{
if (strcmp(info.elemVec[i].name.c_str(), "vertex") == 0)
WriteBinaryElement<VertexAdaptorTuple>(vertexAdaptor, info.elemVec[i], fp);
else if (strcmp(info.elemVec[i].name.c_str(), "face") == 0)
WriteBinaryElement<FaceAdaptorTuple>(faceAdaptor, info.elemVec[i], fp);
}
}
else
{
for(int i = 0; i < info.elemVec.size();++i)
{
if (strcmp(info.elemVec[i].name.c_str(), "vertex") == 0)
WriteAsciiElement<VertexAdaptorTuple>(vertexAdaptor, info.elemVec[i], fp);
else if (strcmp(info.elemVec[i].name.c_str(), "face") == 0)
WriteAsciiElement<FaceAdaptorTuple>(faceAdaptor, info.elemVec[i], fp);
}
}
fclose(fp);
return true;
}
/**
* @cond HIDDEN_SYMBOLS
*/
template < typename TupleType, size_t ActionType>
inline bool TupleForEach( TupleType &tuple, FILE *fp, PlyProperty &pro, bool bigEndian, SizeT<ActionType> a)
{
return TupleForEach( tuple, pro, fp, bigEndian, SizeT<std::tuple_size<TupleType>::value>(), a);
}
template < typename TupleType, size_t ActionType>
inline bool TupleForEach( TupleType &tuple, PlyProperty &pro, FILE *fp, bool bigEndian, SizeT<0> t, SizeT<ActionType> a) {return false; }
template < typename TupleType, size_t N, size_t ActionType>
inline bool TupleForEach( TupleType &tuple, PlyProperty &pro, FILE *fp, bool bigEndian, SizeT<N> t, SizeT<ActionType> a)
{
typename std::tuple_element<N - 1, TupleType>::type &dataDescr = std::get<N -1>(tuple);
if (ActionType == 0)
{
if (dataDescr.ReadElemBinary(fp, pro, bigEndian))
return true;
}
else if (ActionType == 1)
{
if (dataDescr.ReadElemAscii(fp, pro))
return true;
}
else if (ActionType == 2)
{
if (dataDescr.WriteElemBinary(fp, pro))
return true;
}
else if (ActionType == 3)
{
if (dataDescr.WriteElemAscii(fp, pro))
return true;
}
return TupleForEach( tuple, pro, fp, bigEndian, SizeT<N-1>(), a);
}
/**
* @endcond
*/
} // end namespace nanoply
#endif // NANOPLY_HPP
Reference in New Issue View Git Blame Copy Permalink