demonkenny/MAXINE-AR-SDK
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
MAXINE-AR-SDK/samples/ExpressionApp/BackEndOpenGL/FaceIO.cpp
jdsouza90 cf68600c4f v0.8.1.0 Release 
v0.8.1.0 Release
2022-09-20 09:59:34 -07:00

2379 lines
87 KiB
C++
Raw Permalink Blame History

/*###############################################################################
#
# Copyright 2019-2021 NVIDIA Corporation
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of
# this software and associated documentation files (the "Software"), to deal in
# the Software without restriction, including without limitation the rights to
# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
# the Software, and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
###############################################################################*/
#include "FaceIO.h"
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <string>
#include <vector>
#ifdef _MSC_VER
#define strcasecmp _stricmp
#define strncasecmp _strnicmp
#endif /* _MSC_VER */
#define BAIL_IF_ERR(err) do { if ((err) != 0) { goto bail; } } while(0)
#define BAIL_IF_ZERO(x, err, code) do { if ((x) == 0) { err = code; goto bail; } } while(0)
#define BAIL_IF_NONZERO(x, err, code) do { if ((x) != 0) { err = code; goto bail; } } while(0)
#define BAIL_IF_FALSE(x, err, code) do { if (!(x)) { err = code; goto bail; } } while(0)
#define BAIL_IF_TRUE(x, err, code) do { if ((x)) { err = code; goto bail; } } while(0)
#define BAIL_IF_NULL(x, err, code) do { if ((void*)(x) == NULL) { err = code; goto bail; } } while(0)
#define BAIL_IF_NEGATIVE(x, err, code) do { if ((x) < 0) { err = code; goto bail; } } while(0)
#define BAIL_IF_NONPOSITIVE(x, err, code) do { if (!((x) > 0)) { err = code; goto bail; } } while(0)
#define BAIL(err, code) do { err = code; goto bail; } while(0)
#ifndef __BYTE_ORDER__ /* How bytes are packed into a 32 bit word */
#define __ORDER_LITTLE_ENDIAN__ 3210 /* First byte in the least significant position */
#define __ORDER_BIG_ENDIAN__ 0123 /* First byte in the most significant position */
#ifdef _MSC_VER
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
#endif /* _MSC_VER */
#endif /* __BYTE_ORDER__ */
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define IOFOURCC(w, o, r, d) (((w) << 24) | ((o) << 16) | ((r) << 8) | ((d) << 0))
#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define IOFOURCC(w, o, r, d) (((d) << 24) | ((r) << 16) | ((o) << 8) | ((w) << 0))
#endif /* __BYTE_ORDER__ */
/********************************************************************************
********************************************************************************
********************************************************************************
***** Utilities *****
********************************************************************************
********************************************************************************
********************************************************************************/
/********************************************************************************
* HasSuffix
********************************************************************************/
static bool HasSuffix(const char *str, const char *suf) {
size_t strSize = strlen(str),
sufSize = strlen(suf);
if (strSize < sufSize)
return false;
return (0 == strcasecmp(suf, str + strSize - sufSize));
}
/********************************************************************************
* CopyDoubleToSingleVector
* This works in-place.
********************************************************************************/
static void CopyDoubleToSingleVector(const double *d, float *s, uint32_t n) {
for (float *send = s + n; s != send;) *s++ = (float)(*d++);
}
/********************************************************************************
* CopyUInt32to16Vector
* This works in-place.
********************************************************************************/
static void CopyUInt32to16Vector(const uint32_t *fr, uint16_t *to, uint32_t n) {
for (uint16_t *toEnd = to + n; to != toEnd;) *to++ = (uint16_t)(*fr++);
}
/********************************************************************************
* FaceIOErrorStringFromCode
********************************************************************************/
const char* FaceIOErrorStringFromCode(FaceIOErr err) {
struct ErrStr { FaceIOErr err; const char *str; };
static const ErrStr lut[] = {
{ kIOErrNone, "no error" },
{ kIOErrFileNotFound, "The file was not found" },
{ kIOErrFileOpen, "The file could not be opened" },
{ kIOErrEOF, "A premature end-of-file was encountered" },
{ kIOErrRead, "An error occurred while reading a file" },
{ kIOErrWrite, "An error occurred while writing a file" },
{ kIOErrSyntax, "A parsing syntax error has been encountered" },
{ kIOErrFormat, "The file has an unknown format" },
{ kIOErrParameter, "The parameter has an invalid value" },
};
for (const ErrStr *p = lut; p != &lut[sizeof(lut)/sizeof(lut[0])]; ++p)
if (p->err == err)
return p->str;
static char msg[16];
snprintf(msg, sizeof(msg), "ERR#%d", (int)err);
return msg;
}
/********************************************************************************
* PrintIOError
********************************************************************************/
static void PrintIOError(const char *file, FaceIOErr err) {
if (kIOErrNone == err) return;
printf("\"%s\": %s\n", file, FaceIOErrorStringFromCode(err));
}
/********************************************************************************
* PrintUnknownFormatMessage
********************************************************************************/
static void PrintUnknownFormatMessage(const char *file, const char *msg = nullptr) {
if (!msg) msg = "";
printf("\"%s\": Unknown format %s\n", file, msg);
}
/********************************************************************************
* ReadFileIntoString
********************************************************************************/
static FaceIOErr ReadFileIntoString(const char *file, bool isText, std::string &str) {
FaceIOErr err = kIOErrNone;
FILE *fd = NULL;
long z;
size_t y;
#ifndef _MSC_VER
fd = fopen(file, (isText ? "r" : "rb"));
#else /* _MSC_VER */
BAIL_IF_NONZERO(fopen_s(&fd, file, (isText ? "r" : "rb")), err, kIOErrFileNotFound);
#endif /* _MSC_VER */
BAIL_IF_NULL(fd, err, kIOErrFileNotFound);
fseek(fd, 0L, SEEK_END);
z = ftell(fd);
BAIL_IF_NEGATIVE(z, err, kIOErrRead); /* If there was a seek error, return an appropriate error code */
fseek(fd, 0L, SEEK_SET);
str.resize((unsigned long)z);
y = fread(&str[0], 1, z, fd); /* y differs from z when reading text on Windows, .. */
str.resize(y); /* ... because CRLF --> NL */
bail:
if (fd) fclose(fd);
return err;
}
typedef struct IbugSfmMapper {
unsigned numLandmarks;
uint16_t landmarkMap[50][2];
uint16_t rightContour[8];
uint16_t leftContour[8];
}IbugSfmMapper;
const IbugSfmMapper ibugMapping = {
68,
// Landmarks Mapping for 68 points
{
// 1 to 8 are the right contour landmarks
{9, 33}, // chin bottom
// 10 to 17 are the left contour landmarks
{18, 225}, // right eyebrow outer-corner (18)
{19, 229}, // right eyebrow between middle and outer corner
{20, 233}, // right eyebrow middle, vertical middle (20)
{21, 2086}, // right eyebrow between middle and inner corner
{22, 157}, // right eyebrow inner-corner (19)
{23, 590}, // left eyebrow inner-corner (23)
{24, 2091}, // left eyebrow between inner corner and middle
{25, 666}, // left eyebrow middle (24)
{26, 662}, // left eyebrow between middle and outer corner
{27, 658}, // left eyebrow outer-corner (22)
{28, 2842}, // bridge of the nose (parallel to upper eye lids)
{29, 379}, // middle of the nose, a bit below the lower eye lids
{30, 272}, // above nose-tip (1cm or so)
{31, 114}, // nose-tip (3)
{32, 100}, // right nostril, below nose, nose-lip junction
{33, 2794}, // nose-lip junction
{34, 270}, // nose-lip junction (28)
{35, 2797}, // nose-lip junction
{36, 537}, // left nostril, below nose, nose-lip junction
{37, 177}, // right eye outer-corner (1)
{38, 172}, // right eye pupil top right (from subject's perspective)
{39, 191}, // right eye pupil top left
{40, 181}, // right eye inner-corner (5)
{41, 173}, // right eye pupil bottom left
{42, 174}, // right eye pupil bottom right
{43, 614}, // left eye inner-corner (8)
{44, 624}, // left eye pupil top right
{45, 605}, // left eye pupil top left
{46, 610}, // left eye outer-corner (2)
{47, 607}, // left eye pupil bottom left
{48, 606}, // left eye pupil bottom right
{49, 398}, // right mouth corner (12)
{50, 315}, // upper lip right top outer
{51, 413}, // upper lip middle top right
{52, 329}, // upper lip middle top (14)
{53, 825}, // upper lip middle top left
{54, 736}, // upper lip left top outer
{55, 812}, // left mouth corner (13)
{56, 841}, // lower lip left bottom outer
{57, 693}, // lower lip middle bottom left
{58, 411}, // lower lip middle bottom (17)
{59, 264}, // lower lip middle bottom right
{60, 431}, // lower lip right bottom outer
// 61 not defined - would be right inner corner of the mouth
{62, 416}, // upper lip right bottom outer
{63, 423}, // upper lip middle bottom
{64, 828}, // upper lip left bottom outer
// 65 not defined - would be left inner corner of the mouth
{66, 817}, // lower lip left top outer
{67, 442}, // lower lip middle top
{68, 404}, // lower lip right top outer
},
{1, 2, 3, 4, 5, 6, 7, 8}, // ibug right contour points
{10, 11, 12, 13, 14, 15, 16, 17} // ibug left contour points
};
/********************************************************************************
********************************************************************************
* NVF Encapsulated object definitions
********************************************************************************
********************************************************************************/
/********************************************************************************
* Object encapsulation. The type is usually a FOURCC.
********************************************************************************/
struct EOTypeSize {
uint32_t type, size;
};
/********************************************************************************
* FOURCC types
********************************************************************************/
#define FOURCC_ADJACENT_FACES IOFOURCC('A', 'J', 'F', 'C')
#define FOURCC_ADJACENT_VERTICES IOFOURCC('A', 'J', 'V', 'X')
#define FOURCC_BASIS IOFOURCC('B', 'S', 'I', 'S')
#define FOURCC_BLEND_SHAPES IOFOURCC('B', 'L', 'N', 'D')
#define FOURCC_COLOR IOFOURCC('C', 'O', 'L', 'R')
#define FOURCC_EIGENVALUES IOFOURCC('E', 'I', 'V', 'L')
#define FOURCC_FILE_TYPE IOFOURCC('N', 'F', 'A', 'C')
#define FOURCC_IBUG IOFOURCC('I', 'B', 'U', 'G')
#define FOURCC_LANDMARK_MAP IOFOURCC('L', 'M', 'R', 'K')
#define FOURCC_LEFT_CONTOUR IOFOURCC('L', 'C', 'T', 'R')
#define FOURCC_MEAN IOFOURCC('M', 'E', 'A', 'N')
#define FOURCC_MODEL IOFOURCC('M', 'O', 'D', 'L')
#define FOURCC_MODEL_CONTOUR IOFOURCC('M', 'C', 'T', 'R')
#define FOURCC_NAME IOFOURCC('N', 'A', 'M', 'E')
#define FOURCC_RIGHT_CONTOUR IOFOURCC('R', 'C', 'T', 'R')
#define FOURCC_SHAPE IOFOURCC('S', 'H', 'A', 'P')
#define FOURCC_TEXTURE_COORDS IOFOURCC('T', 'X', 'C', 'O')
#define FOURCC_EOTOC IOFOURCC('T', 'O', 'C', '0')
#define FOURCC_TOPOLOGY IOFOURCC('T', 'O', 'P', 'O')
#define FOURCC_TRIANGLE_LIST IOFOURCC('T', 'R', 'N', 'G')
#define FOURCC_NVLM IOFOURCC('N', 'V', 'L', 'M')
#define FOURCC_PARTITIONS IOFOURCC('P', 'R', 'T', 'S')
#define FOURCC_PART IOFOURCC('P', 'A', 'R', 'T')
#define FOURCC_MATERIAL IOFOURCC('M', 'T', 'R', 'L')
/********************************************************************************
* NVFFileHeader
********************************************************************************/
struct NVFFileHeader {
enum { // Illustrate 2 bit packets packed into a byte by the specified scheme
LITTLE_ENDIAN_CODE = 0xE4, // = 11 10 01 00 // or 0x10 = 0001 0000 -- 4 bit packets
BIG_ENDIAN_CODE = 0x1B // = 00 01 10 11 // or 0x01 = 0000 0001
};
unsigned type;
unsigned size;
unsigned char endian, sizeBits, indexBits, zero;
unsigned tocLoc;
NVFFileHeader() {
type = FOURCC_FILE_TYPE;
size = sizeof(*this) - sizeof(type) - sizeof(size);
endian = LITTLE_ENDIAN_CODE;
sizeBits = 32; // 32 bits for the object size
indexBits = 16; // 16 bits for indices
zero = 0;
tocLoc = 0;
}
void clear() { memset(this, 0, sizeof(*this)); }
static unsigned EOTOCOffset() {
return (char *)(&((NVFFileHeader *)nullptr)->tocLoc) - (char *)(&((NVFFileHeader *)nullptr)->type);
}
};
namespace { // anonymous
/********************************************************************************
********************************************************************************
* EOWriter - Encapsulated Object Writer
********************************************************************************
********************************************************************************/
class EOWriter
{
public:
EOWriter();
~EOWriter();
/// Open a file for writing.
/// @param[in] fileName the name of the file to be written to.
/// @return kIOErrNone if the file was opened successfully.
/// @return kIOErrWrite if there were problems opening the file for writing.
FaceIOErr open(const char *fileName);
/// Close the file without writing the table of contents, and flush the output.
FaceIOErr close();
/// Write the table of contents and close the file.
/// @param[in] tocRefOffset the offset from the beginning of the file where the location of the TOC is stored.
/// @return kIOErrNone if the operation was completed successfully.
FaceIOErr writeTocAndClose(unsigned tocRefOffset);
/// Get the file descriptor.
/// @return the file descriptor, or NULL if there is no open file.
FILE* fileDescriptor();
/// Write the object encapsulation header.
/// @param[in] type a FOURCC 4-byte code.
/// @param[in] size a 4-byte size for the remainder of the object.
/// @param[in] tag a tag for the TOC. 0 makes no entry into the TOC.
/// Usually the outer objects are in the TOC. But one may also include
/// subobjects in the TOC, or no objects at all.
/// @return kIOErrNone if the operation was completed successfully.
FaceIOErr writeEncapsulationHeader(unsigned type, unsigned size, unsigned tag = 0);
/// Write an encapsulated opaque object.
/// @param[in] type a FOURCC 4-byte code.
/// @param[in] size the size in bytes of the data to be written.
/// @param[in] data the data to be written.
/// @param[in] tag a tag for the TOC. 0 makes no entry into the TOC.
/// Usually the outer objects are in the TOC. But one may also include
/// subobjects in the TOC, or no objects at all.
/// @return kIOErrNone if the operation was completed successfully.
FaceIOErr writeOpaqueObject(unsigned type, unsigned size, const void *data, unsigned tag = 0);
FaceIOErr writeOpaqueObject(unsigned type, size_t size, const void *data, unsigned tag = 0)
{ return writeOpaqueObject(type, (unsigned)size, data, tag); }
/// Write opaque data
/// @param[in] size the size in bytes of the data to be written.
/// @param[in] data the data to be written.
/// @return kIOErrNone if the operation was completed successfully.
FaceIOErr writeData(unsigned size, const void *data);
FaceIOErr writeData(size_t size, const void *data) { return writeData((unsigned)size, data); }
private:
struct Impl;
Impl *pimpl;
};
struct EOTOC {
unsigned _tag;
unsigned _offset;
EOTOC(unsigned tag, unsigned offset) {
_tag = tag;
_offset = offset;
}
};
struct EOEncapsulation {
unsigned _type, _size;
EOEncapsulation(unsigned type, unsigned size) {
_type = type;
_size = size;
}
};
struct EOWriter::Impl {
FILE *fd;
std::vector<EOTOC> toc;
void addToEOTOC(unsigned tag) {
if (tag) toc.emplace_back(tag, (unsigned)ftell(fd));
}
};
EOWriter::EOWriter() {
pimpl = new EOWriter::Impl;
pimpl->fd = nullptr;
}
EOWriter::~EOWriter() {
if (pimpl->fd) fclose(pimpl->fd);
delete pimpl;
}
FILE *EOWriter::fileDescriptor() { return pimpl->fd; }
FaceIOErr EOWriter::open(const char *fileName) {
pimpl->fd = nullptr;
#ifndef _MSC_VER
pimpl->fd = fopen(fileName, "wb");
#else /* _MSC_VER */
if (0 != fopen_s(&pimpl->fd, fileName, "wb"))
pimpl->fd = nullptr;
#endif /* _MSC_VER */
return pimpl->fd ? kIOErrNone : kIOErrWrite;
}
FaceIOErr EOWriter::close() {
fclose(pimpl->fd);
pimpl->fd = nullptr;
return kIOErrNone;
}
FaceIOErr EOWriter::writeEncapsulationHeader(unsigned type, unsigned size, unsigned tag) {
EOEncapsulation eo(type, size);
pimpl->addToEOTOC(tag);
size_t z = fwrite(&eo, sizeof(eo._type), sizeof(eo) / sizeof(eo._type), pimpl->fd);
return (z == (sizeof(eo) / sizeof(eo._type))) ? kIOErrNone : kIOErrWrite;
}
FaceIOErr EOWriter::writeData(unsigned size, const void *data) {
return (1 == fwrite(data, size, 1, pimpl->fd)) ? kIOErrNone : kIOErrWrite;
}
FaceIOErr EOWriter::writeOpaqueObject(unsigned type, unsigned size, const void *data, unsigned tag) {
FaceIOErr err = writeEncapsulationHeader(type, size, tag);
if (!err) err = writeData(size, data);
return err;
}
FaceIOErr EOWriter::writeTocAndClose(unsigned tocRefOffset) {
FaceIOErr err = kIOErrNone;
unsigned numRecords = (unsigned)pimpl->toc.size();
if (numRecords) {
unsigned offset = ftell(pimpl->fd),
size = sizeof(unsigned) + numRecords * sizeof(EOTOC);
err = writeEncapsulationHeader(FOURCC_EOTOC, size, 0);
if (kIOErrNone == err) {
unsigned recordSize = sizeof(EOTOC);
BAIL_IF_ERR(
err = (1 == fwrite(&recordSize, sizeof(recordSize), 1, pimpl->fd))
? kIOErrNone
: kIOErrWrite);
BAIL_IF_ERR(err = (numRecords == fwrite(pimpl->toc.data(), sizeof(EOTOC),
numRecords, pimpl->fd))
? kIOErrNone
: kIOErrWrite);
BAIL_IF_NONZERO(fseek(pimpl->fd, tocRefOffset, SEEK_SET), err,
kIOErrWrite);
BAIL_IF_ERR(err = (1 == fwrite(&offset, sizeof(offset), 1, pimpl->fd))
? kIOErrNone
: kIOErrWrite);
}
}
fclose(pimpl->fd);
pimpl->fd = nullptr;
bail:
return err;
}
/********************************************************************************
********************************************************************************
* JSON reader and writer
********************************************************************************
********************************************************************************/
enum JSONNodeType {
kJSONObject,
kJSONArray,
kJSONString,
kJSONNumber,
kJSONMember,
kJSONBoolean,
kJSONNull
};
struct JSONInfo {
void *userData;
JSONNodeType type;
const char *value;
double number;
};
typedef FaceIOErr (*JSONOpenNodeProc)(JSONInfo *info);
typedef FaceIOErr (*JSONCloseNodeProc)(JSONInfo *info);
class JSONReader {
public:
JSONReader(JSONOpenNodeProc openNode, JSONCloseNodeProc closeNode);
~JSONReader() {}
/// Parse from a string.
/// @param[in] str the string to be parsed.
/// @param[in] len the length of the string to be parsed; if 0, it is
/// assumed to be NULL-terminated.
/// @param[in,out] state the parser state.
/// @return kIOErrNone if the operation was completed successfully.
/// @return kIOErrSyntax if a syntax error occurred during parsing.
/// @return kIOErrEOF if the file ended sooner than expected.
FaceIOErr parse(const char *str, size_t len, void *state);
/// Parse from a file.
/// @param[in] fileName the file to be parsed.
/// @param[in,out] state the parser state.
/// @return kIOErrNone if the operation was completed successfully.
/// @return kIOErrSyntax if a syntax error occurred during parsing.
/// @return kIOErrEOF if the file ended sooner than expected.
FaceIOErr parse(const char *fileName, void *state);
private:
JSONOpenNodeProc _openNode;
JSONCloseNodeProc _closeNode;
const char *_jsonStr;
size_t _jsonLen;
JSONInfo _infoBack;
void skipWhiteSpace();
FaceIOErr readNumber();
FaceIOErr readString();
FaceIOErr readValue();
FaceIOErr readArray();
FaceIOErr readObject();
FaceIOErr getString(std::string *str);
};
class JSONWriter {
public:
JSONWriter();
~JSONWriter();
FaceIOErr open(const char *file);
FaceIOErr close();
void openObject(const char *tag = nullptr);
void closeObject();
void openArray(const char *tag = nullptr);
void closeArray();
void writeNumericArray(unsigned n, const float *v, unsigned maxRow = 0, const char *tag = nullptr);
void writeNumericArray(unsigned n, const double *v, unsigned maxRow = 0, const char *tag = nullptr);
void writeNumericArray(unsigned n, const int *v, unsigned maxRow = 0, const char *tag = nullptr);
void writeNumericArray(unsigned n, const unsigned short *v, unsigned maxRow = 0, const char *tag = nullptr);
void writeNumericArray(unsigned n, const unsigned char *v, unsigned maxRow = 0, const char *tag = nullptr);
void writeNumber(double number, const char *tag = nullptr);
void writeString(const char *str, const char *tag = nullptr);
void writeBool(bool value, const char *tag = nullptr);
void writeNull(const char *tag = nullptr);
private:
class Impl;
Impl *pimpl;
};
JSONReader::JSONReader(JSONOpenNodeProc openNode, JSONCloseNodeProc closeNode) {
_openNode = openNode;
_closeNode = closeNode;
_jsonStr = nullptr;
_jsonLen = 0;
_infoBack.userData = nullptr;
_infoBack.type = kJSONNull;
_infoBack.value = nullptr;
_infoBack.number = NAN;
}
void JSONReader::skipWhiteSpace() {
for (; _jsonLen && isspace(*_jsonStr); ++_jsonStr, --_jsonLen) {}
}
FaceIOErr JSONReader::getString(std::string *str) {
FaceIOErr err = kIOErrNone;
const char *s;
char c, quote;
size_t n;
str->clear();
BAIL_IF_FALSE(_jsonLen > 2, err, kIOErrEOF); /* not enough characters */
n = _jsonLen;
c = *(s = _jsonStr);
BAIL_IF_FALSE(('"' == c || '\'' == c), err, kIOErrSyntax); /* missing quotes */
quote = c;
for (--n, ++s; n--; s++)
if (quote == *s) /* TODO: check for escapes */
break;
n = s - _jsonStr + 1;
BAIL_IF_FALSE(n >= 2, err, kIOErrEOF); /* not enough characters */
str->assign(_jsonStr + 1, n - 2);
_jsonStr += n;
_jsonLen -= n;
bail:
if (kIOErrSyntax == err) printf("Expecting a string, but found no quotes\n");
return err;
}
FaceIOErr JSONReader::readString() {
FaceIOErr err;
std::string str;
BAIL_IF_ERR(err = getString(&str));
_infoBack.type = kJSONString;
_infoBack.value = str.c_str();
BAIL_IF_ERR(err = (*_openNode)(&_infoBack));
err = (*_closeNode)(&_infoBack);
bail:
_infoBack.value = nullptr; /* Make Coverity happy */
return err;
}
FaceIOErr JSONReader::readObject() {
FaceIOErr err;
std::string str;
_infoBack.type = kJSONObject; /* Open an object node */
_infoBack.value = nullptr;
BAIL_IF_ERR(err = (*_openNode)(&_infoBack));
BAIL_IF_FALSE('{' == _jsonStr[0], err, kIOErrSyntax); /* This is where we always start */
--_jsonLen;
BAIL_IF_ZERO(_jsonLen, err, kIOErrEOF);
++_jsonStr;
skipWhiteSpace();
if ('}' != _jsonStr[0]) {
do {
skipWhiteSpace();
BAIL_IF_ERR(err = getString(&str)); /* Every member must have a name */
skipWhiteSpace();
BAIL_IF_ZERO(_jsonLen, err, kIOErrEOF);
BAIL_IF_FALSE(':' == _jsonStr[0], err, kIOErrSyntax); /* Followed by a colon */
--_jsonLen;
BAIL_IF_ZERO(_jsonLen, err, kIOErrEOF);
++_jsonStr;
skipWhiteSpace();
_infoBack.type = kJSONMember; /* Start a new member */
_infoBack.value = str.c_str();
BAIL_IF_ERR(err = (*_openNode)(&_infoBack));
BAIL_IF_ERR(err = readValue()); /* Get the member */
_infoBack.type = kJSONMember; /* Close the member */
BAIL_IF_ERR(err = (*_closeNode)(&_infoBack));
skipWhiteSpace();
BAIL_IF_ZERO(_jsonLen, err, kIOErrEOF);
if ('}' == _jsonStr[0]) /* Look for ending */
break; /* Normal object exit */
BAIL_IF_FALSE(',' == _jsonStr[0], err, kIOErrNotValue); /* Comma-separated members */
--_jsonLen;
BAIL_IF_ZERO(_jsonLen, err, kIOErrEOF);
++_jsonStr;
} while (1);
}
--_jsonLen; /* Always ('}' == _jsonStr[0]) here */
++_jsonStr;
_infoBack.type = kJSONObject; /* Close the object node */
_infoBack.value = nullptr;
err = (*_closeNode)(&_infoBack);
bail:
_infoBack.value = nullptr; /* Make Coverity happy */
return err;
}
FaceIOErr JSONReader::readArray() {
FaceIOErr err;
_infoBack.type = kJSONArray;
_infoBack.value = nullptr;
BAIL_IF_ERR(err = (*_openNode)(&_infoBack));
BAIL_IF_FALSE('[' == _jsonStr[0], err, kIOErrSyntax); /* We always enter in this state */
--_jsonLen;
BAIL_IF_ZERO(_jsonLen, err, kIOErrEOF);
++_jsonStr;
skipWhiteSpace();
if (']' != _jsonStr[0]) {
do {
skipWhiteSpace();
BAIL_IF_ERR(err = readValue());
skipWhiteSpace();
BAIL_IF_ZERO(_jsonLen, err, kIOErrEOF);
if (']' == _jsonStr[0]) break;
BAIL_IF_FALSE(',' == _jsonStr[0], err, kIOErrEOF);
--_jsonLen;
BAIL_IF_ZERO(_jsonLen, err, kIOErrEOF);
++_jsonStr;
} while (1);
}
--_jsonLen; /* Always (']' == _jsonStr[0]) here */
++_jsonStr;
_infoBack.type = kJSONArray;
_infoBack.value = nullptr;
err = (*_closeNode)(&_infoBack);
bail:
return err;
}
FaceIOErr JSONReader::readNumber() {
FaceIOErr err = kIOErrNone;
char *endPtr;
size_t n;
std::string str;
_infoBack.number = strtod(_jsonStr, &endPtr); /* Parse the number */
n = endPtr - _jsonStr;
BAIL_IF_FALSE(n <= _jsonLen, err, kIOErrEOF);
BAIL_IF_ZERO(n, err, kIOErrSyntax);
str.assign(_jsonStr, n);
_jsonStr += n;
_infoBack.type = kJSONNumber; /* Open bracket */
_infoBack.value = str.c_str();
BAIL_IF_ERR(err = (*_openNode)(&_infoBack));
err = (*_closeNode)(&_infoBack); /* Close bracket */
bail:
_infoBack.value = nullptr; /* Make Coverity happy */
return err;
}
FaceIOErr JSONReader::readValue() {
static const char kTrue[] = "true", kFalse[] = "false", kNull[] = "null";
FaceIOErr err = kIOErrNotValue;
skipWhiteSpace();
BAIL_IF_ZERO(_jsonLen, err, kIOErrEOF);
if ('{' == _jsonStr[0]) // Object
return readObject();
if ('[' == _jsonStr[0]) // Array
return readArray();
if ('"' == _jsonStr[0] || '\'' == _jsonStr[0]) // String
return readString();
if (('0' <= _jsonStr[0] && _jsonStr[0] <= '9') || // Number
'-' == _jsonStr[0] || '+' == _jsonStr[0] || '.' == _jsonStr[0])
return readNumber();
if (_jsonLen >= 4 && !strncasecmp(_jsonStr, kTrue, 4)) // Boolean true
{ // TODO: look out for "true" token prefix
_jsonStr += 4;
_jsonLen -= 4;
_infoBack.type = kJSONBoolean;
_infoBack.value = kTrue;
BAIL_IF_ERR(err = (*_openNode)(&_infoBack));
return (*_closeNode)(&_infoBack);
}
if (_jsonLen >= 5 && !strncasecmp(_jsonStr, kFalse, 5)) // Boolean false
{ // TODO: look out for "false" token prefix
_jsonStr += 5;
_jsonLen -= 5;
_infoBack.type = kJSONBoolean;
_infoBack.value = kFalse;
BAIL_IF_ERR(err = (*_openNode)(&_infoBack));
return (*_closeNode)(&_infoBack);
}
if (_jsonLen >= 4 && !strncasecmp(_jsonStr, kNull, 4)) // null
{ // TODO: look out for " null" token prefix
_jsonStr += 4;
_jsonLen -= 4;
_infoBack.type = kJSONNull;
_infoBack.value = kNull;
BAIL_IF_ERR(err = (*_openNode)(&_infoBack));
return (*_closeNode)(&_infoBack);
}
bail:
return err;
}
FaceIOErr JSONReader::parse(const char *str, size_t len, void *userState) {
FaceIOErr err;
_jsonStr = str;
_jsonLen = len ? len : strlen(str);
_infoBack.userData = userState;
err = readValue();
if (kIOErrNone != err) printf("Syntax error at \"%.32s...\"\n", _jsonStr);
return err;
}
FaceIOErr JSONReader::parse(const char *fileName, void *userState) {
std::string str;
FaceIOErr err = ReadFileIntoString(fileName, true, str);
if (kIOErrNone == err) err = parse(str.c_str(), str.size(), userState);
return err;
}
class JSONWriter::Impl {
public:
int level;
FILE *fd;
std::stack<int> count;
void doIndent();
void maybeComma();
void maybeTag(const char *tag);
void commaIndentTag(const char *tag);
template<typename T> void writeArray(unsigned n, const T *v, unsigned maxRow, const char *fmt, const char *tag);
void openObject(const char *tag);
void closeObject();
void openArray(const char *tag);
void closeArray();
};
void JSONWriter::Impl::doIndent() {
for (int i = level * 2; i-- > 0;) putc(' ', fd);
}
void JSONWriter::Impl::maybeComma() {
if (count.top())
putc(',', fd);
count.top()++;
}
void JSONWriter::Impl::maybeTag(const char *tag) {
if (!tag) return;
fprintf(fd, "\"%s\": ", tag);
}
void JSONWriter::Impl::commaIndentTag(const char *tag) {
maybeComma();
if (level) putc('\n', fd);
doIndent();
maybeTag(tag);
}
void JSONWriter::Impl::openObject(const char *tag)
{
commaIndentTag(tag);
putc('{', fd);
++(level);
count.push(0);
}
void JSONWriter::Impl::closeObject()
{
--(level);
putc('\n', fd);
doIndent();
putc('}', fd);
count.pop();
}
void JSONWriter::Impl::openArray(const char *tag)
{
commaIndentTag(tag);
putc('[', fd);
++(level);
count.push(0);
}
void JSONWriter::Impl::closeArray()
{
--(level);
putc('\n', fd);
doIndent();
putc(']', fd);
count.pop();
}
JSONWriter::JSONWriter() {
pimpl = new Impl();
pimpl->level = 0;
pimpl->fd = nullptr;
pimpl->count.push(0);
}
JSONWriter::~JSONWriter() {
if (pimpl->fd && pimpl->fd != stdout) fclose(pimpl->fd);
delete pimpl;
}
FaceIOErr JSONWriter::open(const char *file) {
if (pimpl->fd && pimpl->fd != stdout) (void)(this->close());
if (file && file[0]) {
#ifndef _MSC_VER
pimpl->fd = fopen(file, "w");
#else /* _MSC_VER */
if (0 != fopen_s(&pimpl->fd, file, "w"))
pimpl->fd = nullptr;
#endif /* _MSC_VER */
} else {
pimpl->fd = stdout;
}
return pimpl->fd ? kIOErrNone : kIOErrWrite;
}
FaceIOErr JSONWriter::close() {
putc('\n', pimpl->fd);
if (pimpl->fd && pimpl->fd != stdout) (void)fclose(pimpl->fd);
pimpl->fd = nullptr;
return kIOErrNone;
}
void JSONWriter::openObject(const char *tag) {
pimpl->openObject(tag);
}
void JSONWriter::closeObject() {
pimpl->closeObject();
}
void JSONWriter::openArray(const char *tag) {
pimpl->openArray(tag);
}
void JSONWriter::closeArray() {
pimpl->closeArray();
}
template<typename T>
void JSONWriter::Impl::writeArray(unsigned n, const T * v, unsigned maxRow, const char *fmt, const char * tag)
{
openArray(tag);
putc('\n', fd);
if (n) {
for (; n > maxRow; n -= maxRow) {
doIndent();
for (unsigned i = maxRow; i--; ++v) {
fprintf(fd, fmt, *v, (i ? ' ' : '\n'));
putc(',', fd);
putc((i ? ' ' : '\n'), fd);
}
}
doIndent();
for (; n--; ++v) {
fprintf(fd, fmt, *v, (n ? ", " : ""));
if (n)
fprintf(fd, ", ");
}
}
closeArray();
}
void JSONWriter::writeNumericArray(unsigned n, const float *v, unsigned maxRow, const char *tag) {
pimpl->writeArray(n, v, maxRow, "%.8g", tag);
}
void JSONWriter::writeNumericArray(unsigned n, const double *v, unsigned maxRow, const char *tag) {
pimpl->writeArray(n, v, maxRow, "%.17g", tag);
}
void JSONWriter::writeNumericArray(unsigned n, const int *v, unsigned maxRow, const char *tag) {
pimpl->writeArray(n, v, maxRow, "%d", tag);
}
void JSONWriter::writeNumericArray(unsigned n, const unsigned short *v, unsigned maxRow, const char *tag) {
pimpl->writeArray(n, v, maxRow, "%u", tag);
}
void JSONWriter::writeNumericArray(unsigned n, const unsigned char *v, unsigned maxRow, const char *tag) {
pimpl->writeArray(n, v, maxRow, "%u", tag);
}
void JSONWriter::writeNumber(double number, const char *tag) {
pimpl->commaIndentTag(tag);
fprintf(pimpl->fd, "%.17g", number);
}
void JSONWriter::writeString(const char *str, const char *tag) {
pimpl->commaIndentTag(tag);
fprintf(pimpl->fd, "\"%s\"", str);
}
void JSONWriter::writeBool(bool value, const char *tag) {
pimpl->commaIndentTag(tag);
fprintf(pimpl->fd, "%s", value ? "true" : "false");
}
void JSONWriter::writeNull(const char *tag) {
pimpl->commaIndentTag(tag);
fprintf(pimpl->fd, "null");
}
} // namespace anonymous
/*******************************************************************************
********************************************************************************
********************************************************************************
***** NVF Output *****
********************************************************************************
********************************************************************************
********************************************************************************/
namespace /* anonymous */ {
template <typename ElementType>
uint32_t NVFSize(uint32_t n, const ElementType *v) {
return (uint32_t)(n * sizeof(*v));
}
template <typename ElementType>
FaceIOErr NVFWriteOpaqueObject(uint32_t type, uint32_t size, const ElementType *v, EOWriter &wtr, unsigned tag = 0) {
return wtr.writeOpaqueObject(type, size * sizeof(*v), v, tag);
}
} // namespace
static uint32_t NVFSizeShapeModel(const FaceIOAdapter *fac) {
uint32_t size = 8 + NVFSize(fac->getShapeMeanSize(), fac->getShapeMean())
+ 8 + NVFSize(fac->getShapeModesSize(), fac->getShapeModes())
+ sizeof(uint32_t)
+ 8 + NVFSize(fac->getShapeEigenvaluesSize(), fac->getShapeEigenvalues())
+ 8 + NVFSize(fac->getTriangleListSize(), fac->getTriangleList());
return size;
}
static FaceIOErr NVFWriteShapeModel(const FaceIOAdapter *fac, EOWriter &wtr) {
FaceIOErr err;
uint32_t numModes = fac->getShapeNumModes(), sizeNumMode = sizeof(uint32_t),
sizeMean = NVFSize(fac->getShapeMeanSize(), fac->getShapeMean()),
sizeModes = NVFSize(fac->getShapeModesSize(), fac->getShapeModes()),
sizeEigen = NVFSize(fac->getShapeEigenvaluesSize(), fac->getShapeEigenvalues()),
sizeTriList = NVFSize(fac->getTriangleListSize(), fac->getTriangleList()),
size = 8 + sizeMean + 8 + sizeModes + sizeNumMode + 8 + sizeEigen + 8 + sizeTriList;
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_SHAPE, size, 0));
BAIL_IF_ERR(err = wtr.writeOpaqueObject(FOURCC_MEAN, sizeMean, fac->getShapeMean(), 0));
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_BASIS, sizeModes + sizeNumMode, 0));
BAIL_IF_ERR(err = wtr.writeData(sizeNumMode, &numModes));
BAIL_IF_ERR(err = wtr.writeData(sizeModes, fac->getShapeModes()));
BAIL_IF_ERR(err = wtr.writeOpaqueObject(FOURCC_EIGENVALUES, sizeEigen, fac->getShapeEigenvalues(), 0));
BAIL_IF_ERR(err = wtr.writeOpaqueObject(FOURCC_TRIANGLE_LIST, sizeTriList, fac->getTriangleList(), 0));
bail:
return err;
}
static uint32_t NVFSizeColorModel(const FaceIOAdapter *fac) {
uint32_t sizeMean = NVFSize(fac->getColorMeanSize(), fac->getColorMean()),
sizeModes = NVFSize(fac->getColorModesSize(), fac->getColorModes()),
sizeEigen = NVFSize(fac->getColorEigenvaluesSize(), fac->getColorEigenvalues()),
sizeTriList = 0, // NVFSize(fac->getTriangleListSize(), fac->getTriangleList());
size = sizeMean + sizeModes + sizeEigen + sizeTriList;
if (size) size += 8 + 8 + 8 + 8;
return size;
}
static FaceIOErr NVFWriteColorModel(const FaceIOAdapter *fac, EOWriter &wtr) {
FaceIOErr err = kIOErrNone;
uint32_t numModes = fac->getColorNumModes(), sizeNumMode = sizeof(uint32_t),
sizeMean = NVFSize(fac->getColorMeanSize(), fac->getColorMean()),
sizeModes = NVFSize(fac->getColorModesSize(), fac->getColorModes()),
sizeEigen = NVFSize(fac->getColorEigenvaluesSize(), fac->getColorEigenvalues()),
sizeTriList = 0, // NVFSize(fac->getTriangleListSize(), fac->getTriangleList());
size = 8 + sizeMean + 8 + sizeModes + sizeNumMode + 8 + sizeEigen + 8 + sizeTriList;
if (sizeMean + sizeModes + sizeEigen != 0) {
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_COLOR, size, 0));
BAIL_IF_ERR(err = wtr.writeOpaqueObject(FOURCC_MEAN, sizeMean, fac->getColorMean(), 0));
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_BASIS, sizeModes + sizeNumMode, 0));
BAIL_IF_ERR(err = wtr.writeData(sizeNumMode, &numModes));
BAIL_IF_ERR(err = wtr.writeData(sizeModes, fac->getColorModes()));
BAIL_IF_ERR(err = wtr.writeOpaqueObject(FOURCC_EIGENVALUES, sizeEigen, fac->getColorEigenvalues(), 0));
BAIL_IF_ERR(err = wtr.writeOpaqueObject(FOURCC_TRIANGLE_LIST, sizeTriList, fac->getTriangleList(), 0));
}
bail:
return err;
}
static uint32_t NVFSizeMorphableModel(const FaceIOAdapter *fac) {
uint32_t size = 8 + NVFSizeShapeModel(fac),
textureSize = NVFSize(fac->getTextureCoordinatesSize(), fac->getTextureCoordinates()),
colorSize = NVFSizeColorModel(fac);
if (textureSize) size += 8 + textureSize;
if (colorSize) size += 8 + colorSize;
return size;
}
static FaceIOErr NVFWriteMorphableModel(const FaceIOAdapter *fac, EOWriter &wtr) {
FaceIOErr err;
uint32_t size;
/* Write the shape model */
BAIL_IF_ERR(err = NVFWriteShapeModel(fac, wtr));
/* Write the color model */
BAIL_IF_ERR(err = NVFWriteColorModel(fac, wtr));
/* Write the texture coordinates */
if (0 != (size = NVFSize(fac->getTextureCoordinatesSize(), fac->getTextureCoordinates())))
BAIL_IF_ERR(err = wtr.writeOpaqueObject(FOURCC_TEXTURE_COORDS, size, fac->getTextureCoordinates()));
bail:
return err;
}
static uint32_t NVFSizeString(const char *str) {
return (strlen(str) + 3) & ~3; // bump up to multiple of 4
}
static FaceIOErr NVFWriteString(const char *str, EOWriter &wtr) {
uint32_t strSize = (uint32_t)strlen(str);
FaceIOErr err = wtr.writeData(strSize, str);
uint32_t pad = (uint32_t)(NVFSizeString(str) - strSize);
BAIL_IF_ERR(err);
if (pad) err = wtr.writeData(pad, "\0\0\0");
bail:
return err;
}
static uint32_t NVFSizeBlendShapes(const FaceIOAdapter *fac) {
uint32_t size = sizeof(uint32_t), // sizeof(numShapes)
numShapes = fac->getNumBlendShapes(), i;
for (i = 0; i < numShapes; ++i) {
size += 8 + NVFSizeString(fac->getBlendShapeName(i));
size += 8 + NVFSize(fac->getBlendShapeSize(i), fac->getBlendShape(i));
}
return size;
}
static FaceIOErr NVFWriteBlendShapes(const FaceIOAdapter *fac, EOWriter &wtr) {
FaceIOErr err = kIOErrNone;
uint32_t numShapes = fac->getNumBlendShapes();
uint32_t i;
BAIL_IF_ERR(err = wtr.writeData(sizeof(numShapes), &numShapes));
for (i = 0; i < numShapes; ++i) {
const char *str = fac->getBlendShapeName(i);
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_NAME, NVFSizeString(str)));
BAIL_IF_ERR(err = NVFWriteString(str, wtr));
BAIL_IF_ERR(err = NVFWriteOpaqueObject(FOURCC_SHAPE, fac->getBlendShapeSize(i), fac->getBlendShape(i), wtr));
}
bail:
return err;
}
static uint32_t NVFSizeIbugMappings(const FaceIOAdapter *fac) {
uint32_t size;
size = 8 + NVFSize(fac->getIbugLandmarkMappingsSize(), fac->getIbugLandmarkMappings())
+ 8 + NVFSize(fac->getIbugRightContourSize(), fac->getIbugRightContour())
+ 8 + NVFSize(fac->getIbugLeftContourSize(), fac->getIbugLeftContour());
return size;
}
static FaceIOErr NVFWriteIbugMappings(const FaceIOAdapter *fac, EOWriter &wtr) {
FaceIOErr err;
BAIL_IF_ERR(err = NVFWriteOpaqueObject(FOURCC_LANDMARK_MAP, fac->getIbugLandmarkMappingsSize(),
fac->getIbugLandmarkMappings(), wtr));
BAIL_IF_ERR(err = NVFWriteOpaqueObject(FOURCC_RIGHT_CONTOUR, fac->getIbugRightContourSize(),
fac->getIbugRightContour(), wtr));
BAIL_IF_ERR(
err = NVFWriteOpaqueObject(FOURCC_LEFT_CONTOUR, fac->getIbugLeftContourSize(), fac->getIbugLeftContour(), wtr));
bail:
return err;
}
static uint32_t NVFSizeModelContours(const FaceIOAdapter *fac) {
uint32_t size = 8 + NVFSize(fac->getModelRightContourSize(), fac->getModelRightContour())
+ 8 + NVFSize(fac->getModelLeftContourSize(), fac->getModelLeftContour());
return size;
}
static FaceIOErr NVFWriteModelContours(const FaceIOAdapter *fac, EOWriter &wtr) {
FaceIOErr err;
BAIL_IF_ERR(err = NVFWriteOpaqueObject(FOURCC_RIGHT_CONTOUR, fac->getModelRightContourSize(),
fac->getModelRightContour(), wtr));
BAIL_IF_ERR(
err = NVFWriteOpaqueObject(FOURCC_LEFT_CONTOUR, fac->getModelLeftContourSize(), fac->getModelLeftContour(), wtr));
bail:
return err;
}
static uint32_t NVFSizeTopology(const FaceIOAdapter *fac) {
uint32_t size = 8 + NVFSize(fac->getAdjacentFacesSize(), fac->getAdjacentFaces()) + 8 +
NVFSize(fac->getAdjacentVerticesSize(), fac->getAdjacentVertices());
return size;
}
static FaceIOErr NVFWriteTopology(const FaceIOAdapter *fac, EOWriter &wtr) {
FaceIOErr err;
BAIL_IF_ERR(
err = NVFWriteOpaqueObject(FOURCC_ADJACENT_FACES, fac->getAdjacentFacesSize(), fac->getAdjacentFaces(), wtr));
BAIL_IF_ERR(err = NVFWriteOpaqueObject(FOURCC_ADJACENT_VERTICES, fac->getAdjacentVerticesSize(),
fac->getAdjacentVertices(), wtr));
bail:
return err;
}
static uint32_t NVFSizeNVLM(const FaceIOAdapter *fac) {
uint32_t size = 8 + NVFSize(fac->getNvlmLandmarksSize(), fac->getNvlmLandmarks())
+ 8 + NVFSize(fac->getNvlmRightContourSize(), fac->getNvlmRightContour())
+ 8 + NVFSize(fac->getNvlmLeftContourSize(), fac->getNvlmLeftContour());
return size;
}
static FaceIOErr NVFWriteNVLM(const FaceIOAdapter *fac, EOWriter &wtr) {
FaceIOErr err;
BAIL_IF_ERR(
err = NVFWriteOpaqueObject(FOURCC_LANDMARK_MAP, fac->getNvlmLandmarksSize(), fac->getNvlmLandmarks(), wtr));
BAIL_IF_ERR(
err = NVFWriteOpaqueObject(FOURCC_RIGHT_CONTOUR, fac->getNvlmRightContourSize(), fac->getNvlmRightContour(), wtr));
BAIL_IF_ERR(
err = NVFWriteOpaqueObject(FOURCC_LEFT_CONTOUR, fac->getNvlmLeftContourSize(), fac->getNvlmLeftContour(), wtr));
bail:
return err;
}
struct TPart {
uint32_t partitionIndex, faceIndex, numFaces, vertexIndex, numVertices;
int32_t smoothingGroup;
};
static uint32_t NVFSizePartitions(const FaceIOAdapter *fac) {
uint32_t numPartitions = fac->getNumPartitions(),
size = sizeof(numPartitions),
i, z;
for (i = 0; i < numPartitions; ++i) {
size += 8; // type, size
size += sizeof(TPart); // partitionIndex, faceIndex, numFaces, vertexIndex, numVertices, smoothingGroup
if (0 != (z = NVFSizeString(fac->getPartitionName(i)))) size += 8 + z;
if (0 != (z = NVFSizeString(fac->getPartitionMaterialName(i)))) size += 8 + z;
}
return size;
}
static FaceIOErr NVFWritePartitions(const FaceIOAdapter *fac, EOWriter &wtr) {
FaceIOErr err = kIOErrNone;
uint32_t numPartitions = fac->getNumPartitions(), i;
EOTypeSize ts;
TPart part;
const char *name, *mtrl;
uint32_t nameSize, mtrlSize;
ts.type = FOURCC_PART;
BAIL_IF_ERR(err = wtr.writeData(sizeof(numPartitions), &numPartitions));
for (i = 0; i < numPartitions; ++i) {
part.partitionIndex = fac->getPartition(
i, &part.faceIndex, &part.numFaces, &part.vertexIndex, &part.numVertices, &part.smoothingGroup);
nameSize = (nullptr != (name = fac->getPartitionName(i)) && name[0]) ? NVFSizeString(name) : 0;
mtrlSize = (nullptr != (mtrl = fac->getPartitionMaterialName(i)) && mtrl[0]) ? NVFSizeString(mtrl) : 0;
ts.size = sizeof(part);
if (nameSize) ts.size += 8 + nameSize;
if (mtrlSize) ts.size += 8 + mtrlSize;
BAIL_IF_ERR(err = wtr.writeData(sizeof(ts), &ts)); // {type,size}
BAIL_IF_ERR(err = wtr.writeData(sizeof(part), &part)); // unencapsulated 6 int16s
if (nameSize) {
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_NAME, nameSize));
BAIL_IF_ERR(err = NVFWriteString(name, wtr));
}
if (mtrlSize) {
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_MATERIAL, mtrlSize));
BAIL_IF_ERR(err = NVFWriteString(mtrl, wtr));
}
}
bail:
return err;
}
/********************************************************************************
* API WriteNVFFaceModel API *
********************************************************************************/
FaceIOErr WriteNVFFaceModel(FaceIOAdapter *fac, const char *fileName) {
FaceIOErr err;
EOWriter wtr;
NVFFileHeader header;
err = wtr.open(fileName);
if (kIOErrNone != err) {
PrintIOError(fileName, err);
goto bail;
}
BAIL_IF_ERR(err = wtr.writeData(sizeof(header), &header));
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_MODEL, NVFSizeMorphableModel(fac), FOURCC_MODEL));
BAIL_IF_ERR(err = NVFWriteMorphableModel(fac, wtr));
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_IBUG, NVFSizeIbugMappings(fac), FOURCC_IBUG));
BAIL_IF_ERR(err = NVFWriteIbugMappings(fac, wtr));
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_BLEND_SHAPES, NVFSizeBlendShapes(fac), FOURCC_BLEND_SHAPES));
BAIL_IF_ERR(err = NVFWriteBlendShapes(fac, wtr));
BAIL_IF_ERR(err =
wtr.writeEncapsulationHeader(FOURCC_MODEL_CONTOUR, NVFSizeModelContours(fac), FOURCC_MODEL_CONTOUR));
BAIL_IF_ERR(err = NVFWriteModelContours(fac, wtr));
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_TOPOLOGY, NVFSizeTopology(fac), FOURCC_TOPOLOGY));
BAIL_IF_ERR(err = NVFWriteTopology(fac, wtr));
if (fac->getNvlmLandmarksSize()) {
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_NVLM, NVFSizeNVLM(fac), FOURCC_NVLM));
BAIL_IF_ERR(err = NVFWriteNVLM(fac, wtr));
}
if (fac->getNumPartitions()) {
BAIL_IF_ERR(err = wtr.writeEncapsulationHeader(FOURCC_PARTITIONS, NVFSizePartitions(fac), FOURCC_PARTITIONS));
BAIL_IF_ERR(err = NVFWritePartitions(fac, wtr));
}
BAIL_IF_ERR(err = wtr.writeTocAndClose(NVFFileHeader::EOTOCOffset()));
bail:
return err;
}
/********************************************************************************
********************************************************************************
********************************************************************************
***** NVF Input *****
********************************************************************************
********************************************************************************
********************************************************************************/
static size_t SafeRead(void *ptr, size_t size, size_t num, FILE *fd) {
if (ptr) return(fread(ptr, size, num, fd));
else return fseek(fd, (long)(size * num), SEEK_CUR) ? 0 : num;
}
static FaceIOErr NVFReadShapeModel(FaceIOAdapter *fac, uint32_t size, FILE *fd) {
FaceIOErr err = kIOErrNone;
EOTypeSize ts;
uint32_t n, numModes;
while (size >= sizeof(ts)) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_MEAN:
n = ts.size / sizeof(*fac->getShapeMean());
BAIL_IF_FALSE(1 == SafeRead(fac->getShapeMean(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_BASIS:
BAIL_IF_FALSE((1 == fread(&numModes, sizeof(numModes), 1, fd)), numModes, 0); // The number of modes
ts.size -= sizeof(numModes); // The byte size of all modes
n = ts.size / sizeof(*fac->getShapeModes()); // The elements size of all nodes
BAIL_IF_FALSE(1 == SafeRead(fac->getShapeModes(n / numModes, numModes), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_EIGENVALUES:
n = ts.size / sizeof(*fac->getShapeEigenvalues());
BAIL_IF_FALSE(1 == SafeRead(fac->getShapeEigenvalues(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_TRIANGLE_LIST:
n = ts.size / sizeof(*fac->getTriangleList());
BAIL_IF_FALSE(1 == SafeRead(fac->getTriangleList(n), ts.size, 1, fd), err, kIOErrRead);
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
bail:
return err;
}
static FaceIOErr NVFReadColorModel(FaceIOAdapter *fac, uint32_t size, FILE *fd) {
FaceIOErr err = kIOErrNone;
EOTypeSize ts;
uint32_t n, numModes;
while (size >= sizeof(ts)) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_MEAN:
n = ts.size / sizeof(*fac->getColorMean());
BAIL_IF_FALSE(1 == SafeRead(fac->getColorMean(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_BASIS:
BAIL_IF_FALSE((1 == fread(&numModes, sizeof(numModes), 1, fd)), numModes, 0); // The number of modes
ts.size -= sizeof(numModes); // The byte size of all modes
n = ts.size / sizeof(*fac->getColorModes()); // The elements size of all nodes
BAIL_IF_FALSE(1 == SafeRead(fac->getColorModes(n / numModes, numModes), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_EIGENVALUES:
n = ts.size / sizeof(*fac->getColorEigenvalues());
BAIL_IF_FALSE(1 == SafeRead(fac->getColorEigenvalues(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_TRIANGLE_LIST:
(void)fseek(fd, ts.size, SEEK_CUR); // Skip color triangle list -- it doesn't make sense
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
bail:
return err;
}
static FaceIOErr NVFReadMorphableModel(FaceIOAdapter *fac, uint32_t size, FILE *fd) {
FaceIOErr err = kIOErrNone;
EOTypeSize ts;
uint32_t n;
while (size >= sizeof(ts)) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_SHAPE:
BAIL_IF_ERR(err = NVFReadShapeModel(fac, ts.size, fd));
break;
case FOURCC_COLOR:
BAIL_IF_ERR(err = NVFReadColorModel(fac, ts.size, fd));
break;
case FOURCC_TEXTURE_COORDS:
n = ts.size / sizeof(*fac->getTextureCoordinates());
BAIL_IF_FALSE(1 == SafeRead(fac->getTextureCoordinates(n), ts.size, 1, fd), err, kIOErrRead);
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
bail:
return err;
}
static FaceIOErr NVFReadString(std::string &str, uint32_t size, FILE *fd) {
str.resize(size);
FaceIOErr err = (size == fread(&str[0], 1, size, fd)) ? kIOErrNone : kIOErrRead;
BAIL_IF_ERR(err);
for (; size; --size)
if (str[size - 1]) break;
str.resize(size); // remove pad
bail:
return err;
}
static FaceIOErr NVFReadBlendShapes(FaceIOAdapter *fac, uint32_t size, FILE *fd) {
uint32_t numShapes;
FaceIOErr err = kIOErrNone;
EOTypeSize ts;
std::string name;
float *shape;
BAIL_IF_FALSE(1 == fread(&numShapes, sizeof(numShapes), 1, fd), err, kIOErrEOF);
fac->setNumBlendShapes(numShapes);
for (uint32_t idxShape = 0, idxName = 0; size >= sizeof(ts);) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_NAME:
BAIL_IF_FALSE(idxName < numShapes, err, kIOErrRead);
BAIL_IF_ERR(err = NVFReadString(name, ts.size, fd));
fac->setBlendShapeName(idxName++, name.c_str());
break;
case FOURCC_SHAPE:
BAIL_IF_FALSE(idxShape < numShapes, err, kIOErrRead);
shape = fac->getBlendShape(idxShape++, ts.size / sizeof(*shape));
BAIL_IF_FALSE(1 == SafeRead(shape, ts.size, 1, fd), err, kIOErrRead);
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
bail:
return err;
}
static FaceIOErr NVFReadIbugMappings(FaceIOAdapter *fac, uint32_t size, FILE *fd) {
FaceIOErr err = kIOErrNone;
EOTypeSize ts;
uint32_t n;
while (size >= sizeof(ts)) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_LANDMARK_MAP:
n = ts.size / sizeof(*fac->getIbugLandmarkMappings());
BAIL_IF_FALSE(1 == SafeRead(fac->getIbugLandmarkMappings(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_RIGHT_CONTOUR:
n = ts.size / sizeof(*fac->getIbugRightContour());
BAIL_IF_FALSE(1 == SafeRead(fac->getIbugRightContour(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_LEFT_CONTOUR:
n = ts.size / sizeof(*fac->getIbugLeftContour());
BAIL_IF_FALSE(1 == SafeRead(fac->getIbugLeftContour(n), ts.size, 1, fd), err, kIOErrRead);
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
bail:
return err;
}
static FaceIOErr NVFReadModelContours(FaceIOAdapter *fac, uint32_t size, FILE *fd) {
FaceIOErr err = kIOErrNone;
;
EOTypeSize ts;
uint32_t n;
while (size >= sizeof(ts)) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_RIGHT_CONTOUR:
n = ts.size / sizeof(*fac->getModelRightContour());
BAIL_IF_FALSE(1 == SafeRead(fac->getModelRightContour(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_LEFT_CONTOUR:
n = ts.size / sizeof(*fac->getModelLeftContour());
BAIL_IF_FALSE(1 == SafeRead(fac->getModelLeftContour(n), ts.size, 1, fd), err, kIOErrRead);
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
bail:
return err;
}
static FaceIOErr NVFReadTopology(FaceIOAdapter *fac, uint32_t size, FILE *fd) {
FaceIOErr err = kIOErrNone;
EOTypeSize ts;
uint32_t n;
while (size >= sizeof(ts)) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_ADJACENT_FACES:
n = ts.size / sizeof(*fac->getAdjacentFaces());
BAIL_IF_FALSE(1 == SafeRead(fac->getAdjacentFaces(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_ADJACENT_VERTICES:
n = ts.size / sizeof(*fac->getAdjacentVertices());
BAIL_IF_FALSE(1 == SafeRead(fac->getAdjacentVertices(n), ts.size, 1, fd), err, kIOErrRead);
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
bail:
return err;
}
static FaceIOErr NVFReadNvlm(FaceIOAdapter *fac, uint32_t size, FILE *fd) {
FaceIOErr err = kIOErrNone;
EOTypeSize ts;
uint32_t n;
while (size >= sizeof(ts)) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_LANDMARK_MAP:
n = ts.size / sizeof(*fac->getNvlmLandmarks());
BAIL_IF_FALSE(1 == SafeRead(fac->getNvlmLandmarks(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_RIGHT_CONTOUR:
n = ts.size / sizeof(*fac->getIbugRightContour());
BAIL_IF_FALSE(1 == SafeRead(fac->getNvlmRightContour(n), ts.size, 1, fd), err, kIOErrRead);
break;
case FOURCC_LEFT_CONTOUR:
n = ts.size / sizeof(*fac->getIbugLeftContour());
BAIL_IF_FALSE(1 == SafeRead(fac->getNvlmLeftContour(n), ts.size, 1, fd), err, kIOErrRead);
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
bail:
return err;
}
static FaceIOErr NVFReadPart(uint32_t i, FaceIOAdapter *fac, uint32_t size, FILE *fd) {
FaceIOErr err = kIOErrNone;
EOTypeSize ts;
TPart part;
std::string name;
BAIL_IF_FALSE(sizeof(part) <= size, err, kIOErrEOF);
BAIL_IF_FALSE(1 == fread(&part, sizeof(part), 1, fd), err, kIOErrEOF);
size -= sizeof(part);
fac->setPartition(i, part.faceIndex, part.numFaces, part.vertexIndex, part.numVertices, part.smoothingGroup);
while (size >= sizeof(ts)) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_NAME:
BAIL_IF_ERR(err = NVFReadString(name, ts.size, fd));
fac->setPartitionName(i, name.c_str());
break;
case FOURCC_MATERIAL:
BAIL_IF_ERR(err = NVFReadString(name, ts.size, fd));
fac->setPartitionMaterialName(i, name.c_str());
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
BAIL_IF_NONZERO(size, err, kIOErrRead); // We are out-of-sync if size != 0
bail:
return err;
}
static FaceIOErr NVFReadPartitions(FaceIOAdapter *fac, uint32_t size, FILE *fd) {
FaceIOErr err = kIOErrNone;
EOTypeSize ts;
uint32_t numPartitions, partIx = 0;
BAIL_IF_FALSE(sizeof(numPartitions) <= size, err, kIOErrEOF);
BAIL_IF_FALSE(1 == fread(&numPartitions, sizeof(numPartitions), 1, fd), err, kIOErrEOF);
size -= sizeof(numPartitions);
fac->setNumPartitions(numPartitions);
for (; size >= sizeof(ts); ++partIx) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_PART:
BAIL_IF_ERR(err = NVFReadPart(partIx, fac, ts.size, fd));
break;
default:
BAIL_IF_NONZERO(fseek(fd, ts.size, SEEK_CUR), err, kIOErrEOF); // We skip over objects we don't understand
break;
}
}
BAIL_IF_NONZERO(size, err, kIOErrRead); // We are out-of-sync if size != 0
bail:
return err;
}
/********************************************************************************
* API ReadNVFFaceModel API *
********************************************************************************/
FaceIOErr ReadNVFFaceModel(const char *fileName, FaceIOAdapter *fac) {
FaceIOErr err = kIOErrNone;
FILE *fd = nullptr;
EOTypeSize ts;
NVFFileHeader header;
uint32_t size;
#ifndef _MSC_VER
fd = fopen(fileName, "rb");
#else /* _MSC_VER */
if (0 != fopen_s(&fd, fileName, "rb"))
fd = nullptr;
#endif /* _MSC_VER */
if (!fd) {
PrintIOError(fileName, err = kIOErrFileOpen);
goto bail;
}
/* Find the length of the file */
BAIL_IF_NEGATIVE(fseek(fd, 0L, SEEK_END), err, kIOErrRead);
size = ftell(fd);
BAIL_IF_NEGATIVE(fseek(fd, 0L, SEEK_SET), err, kIOErrRead);
BAIL_IF_FALSE(size >= sizeof(header), err, kIOErrEOF);
/* Validate header */
BAIL_IF_FALSE(1 == fread(&header, sizeof(header), 1, fd), err, kIOErrRead);
BAIL_IF_FALSE(FOURCC_FILE_TYPE == header.type, err, kIOErrFormat);
BAIL_IF_FALSE(8 <= header.size, err, kIOErrFormat); // TODO: robustify
BAIL_IF_FALSE(NVFFileHeader::LITTLE_ENDIAN_CODE == header.endian, err, kIOErrFormat); // We only handle little-endian
BAIL_IF_FALSE(32 == header.sizeBits, err, kIOErrFormat); // We only use 32 bit sizes
BAIL_IF_FALSE(16 == header.indexBits, err, kIOErrFormat); // We only use 16 bit indices
size -= sizeof(header);
if (header.size > 8) { /* Forward compatibility */
uint32_t extra = header.size - 8;
BAIL_IF_FALSE(size >= extra, err, kIOErrEOF);
size -= extra;
BAIL_IF_NEGATIVE(fseek(fd, extra, SEEK_CUR), err, kIOErrRead);
}
while (size >= sizeof(ts)) {
BAIL_IF_FALSE(1 == fread(&ts, sizeof(ts), 1, fd), err, kIOErrEOF);
size -= sizeof(ts);
BAIL_IF_FALSE(ts.size <= size, err, kIOErrEOF);
size -= ts.size;
switch (ts.type) {
case FOURCC_MODEL:
BAIL_IF_ERR(err = NVFReadMorphableModel(fac, ts.size, fd));
break;
case FOURCC_IBUG:
BAIL_IF_ERR(err = NVFReadIbugMappings(fac, ts.size, fd));
break;
case FOURCC_BLEND_SHAPES:
BAIL_IF_ERR(err = NVFReadBlendShapes(fac, ts.size, fd));
break;
case FOURCC_MODEL_CONTOUR:
BAIL_IF_ERR(err = NVFReadModelContours(fac, ts.size, fd));
break;
case FOURCC_TOPOLOGY:
BAIL_IF_ERR(err = NVFReadTopology(fac, ts.size, fd));
break;
case FOURCC_NVLM:
BAIL_IF_ERR(err = NVFReadNvlm(fac, ts.size, fd));
break;
case FOURCC_PARTITIONS:
BAIL_IF_ERR(err = NVFReadPartitions(fac, ts.size, fd));
break;
case FOURCC_EOTOC:
BAIL_IF_NEGATIVE(fseek(fd, ts.size, SEEK_CUR), err, kIOErrRead); // Skip the EOTOC
break;
default:
BAIL(err, kIOErrSyntax); // TODO: We should just skip over objects we don't understand
}
}
bail:
if (fd) fclose(fd);
return err;
}
/********************************************************************************
********************************************************************************
********************************************************************************
***** EOS Input *****
********************************************************************************
********************************************************************************
********************************************************************************/
#define DEBUG_PARSER 0
static FaceIOErr EOSReadModesSize(uint32_t *oneModeSize, uint32_t *numModes, FILE *fd) {
FaceIOErr err = kIOErrNone;
BAIL_IF_FALSE(1 == fread(oneModeSize, sizeof(*oneModeSize), 1, fd), err, kIOErrRead);
BAIL_IF_FALSE(1 == fread(numModes, sizeof(*numModes), 1, fd), err, kIOErrRead);
bail:
return err;
}
static FaceIOErr EOSReadShapeModel(FaceIOAdapter *fac, FILE *fd) {
FaceIOErr err = kIOErrNone;
uint32_t modeSize, numModes;
uint16_t *tri;
float *data;
long long z;
if (DEBUG_PARSER) printf("Reading Shape Model @ %ld (%#lx)\n", ftell(fd), ftell(fd));
if (DEBUG_PARSER) printf("Reading mean @ %ld (%#lx)\n", ftell(fd), ftell(fd));
BAIL_IF_ERR(err = EOSReadModesSize(&modeSize, &numModes, fd)); // Coverity thinks "read" means "taint"
if (0 != (modeSize *= numModes)) {
BAIL_IF_NULL(data = fac->getShapeMean(modeSize), err, kIOErrNullPointer);
BAIL_IF_FALSE(1 == fread(data, modeSize * sizeof(*data), 1, fd), err, kIOErrRead);
}
if (DEBUG_PARSER) printf("Reading pca_basis @ %ld (%#lx)\n", ftell(fd), ftell(fd));
BAIL_IF_ERR(err = EOSReadModesSize(&modeSize, &numModes, fd));
if (0 != (modeSize * numModes)) {
BAIL_IF_NULL(data = fac->getShapeModes(modeSize, numModes), err, kIOErrNullPointer);
BAIL_IF_FALSE(1 == fread(data, modeSize * numModes * sizeof(*data), 1, fd), err, kIOErrRead);
}
if (DEBUG_PARSER) printf("Reading eigenvalues @ %ld (%#lx)\n", ftell(fd), ftell(fd));
BAIL_IF_ERR(err = EOSReadModesSize(&modeSize, &numModes, fd));
if (modeSize *= numModes) {
BAIL_IF_NULL(data = fac->getShapeEigenvalues(modeSize), err, kIOErrNullPointer);
BAIL_IF_FALSE(1 == fread(data, modeSize * sizeof(*data), 1, fd), err, kIOErrRead);
}
if (DEBUG_PARSER) printf("Reading triangle_list(%lld) @ %ld (%#lx)\n", z, ftell(fd), ftell(fd));
BAIL_IF_FALSE(1 == fread(&z, sizeof(z), 1, fd), err, kIOErrRead);
z *= 3;
tri = fac->getTriangleList((uint32_t)z * 2); // Big enough for uint32_t now, we resize to uint16_t later
BAIL_IF_FALSE(z == (long long)fread(tri, sizeof(uint32_t), z, fd), err, kIOErrRead);
CopyUInt32to16Vector((uint32_t *)tri, tri, (uint32_t)z);
fac->setTriangleListSize((uint32_t)z); // Now it is the actual size
bail:
if (err) printf("Error reading Shape Model\n");
return err;
}
static FaceIOErr EOSReadColorModel(FaceIOAdapter *fac, FILE *fd) {
FaceIOErr err = kIOErrNone;
uint32_t modeSize, numModes;
float *data;
long long z;
if (DEBUG_PARSER) printf("Reading Color Model @ %ld (%#lx)\n", ftell(fd), ftell(fd));
if (DEBUG_PARSER) printf("Reading mean @ %ld (%#lx)\n", ftell(fd), ftell(fd));
BAIL_IF_ERR(err = EOSReadModesSize(&modeSize, &numModes, fd));
if (modeSize *= numModes) {
BAIL_IF_NULL(data = fac->getColorMean(modeSize), err, kIOErrNullPointer);
BAIL_IF_FALSE(1 == fread(data, modeSize * sizeof(*data), 1, fd), err, kIOErrRead);
}
if (DEBUG_PARSER) printf("Reading pca_basis @ %ld (%#lx)\n", ftell(fd), ftell(fd));
BAIL_IF_ERR(err = EOSReadModesSize(&modeSize, &numModes, fd));
if (modeSize * numModes) {
BAIL_IF_NULL(data = fac->getColorModes(modeSize, numModes), err, kIOErrNullPointer);
BAIL_IF_FALSE(1 == fread(data, modeSize * numModes * sizeof(*data), 1, fd), err, kIOErrRead);
}
if (DEBUG_PARSER) printf("Reading eigenvalues @ %ld (%#lx)\n", ftell(fd), ftell(fd));
BAIL_IF_ERR(err = EOSReadModesSize(&modeSize, &numModes, fd));
if (modeSize *= numModes) {
BAIL_IF_NULL(data = fac->getColorEigenvalues(modeSize), err, kIOErrNullPointer);
BAIL_IF_FALSE(1 == fread(data, modeSize * sizeof(*data), 1, fd), err, kIOErrRead);
}
if (DEBUG_PARSER) printf("Skipping triangle_list(%lld) @ %ld (%#lx)\n", z, ftell(fd), ftell(fd));
BAIL_IF_FALSE(1 == fread(&z, sizeof(z), 1, fd), err, kIOErrRead);
z *= 3 * sizeof(uint32_t);
(void)fseek(fd, (long)z, SEEK_CUR);
bail:
if (err) printf("Error reading Color Model\n");
return err;
}
static FaceIOErr EOSReadMorphableModel(FaceIOAdapter *fac, FILE *fd) {
FaceIOErr err = kIOErrNone;
int version;
size_t n1;
long long z;
float *tex;
if (DEBUG_PARSER) printf("Reading TmorphableModel @ %ld (%#lx)\n", ftell(fd), ftell(fd));
n1 = fread(&version, sizeof(version), 1, fd);
BAIL_IF_FALSE(n1 == 1, err, kIOErrRead);
if (DEBUG_PARSER) printf("Version(%d)\n", version);
if (DEBUG_PARSER) printf("Reading shape_model @ %ld (%#lx)\n", ftell(fd), ftell(fd));
BAIL_IF_ERR(err = EOSReadShapeModel(fac, fd));
if (DEBUG_PARSER) printf("Reading color_model @ %ld (%#lx)\n", ftell(fd), ftell(fd));
BAIL_IF_ERR(err = EOSReadColorModel(fac, fd));
BAIL_IF_FALSE(1 == fread(&z, sizeof(z), 1, fd), err, kIOErrRead);
z *= 2; /* 2 floats per texture coordinate */
tex = fac->getTextureCoordinates((uint32_t)z * 2); /* allocate enough space for double precision */
if (DEBUG_PARSER) printf("Reading texture_coordinates(%lld) @ %ld (%#lx)\n", z, ftell(fd), ftell(fd));
BAIL_IF_FALSE(1 == fread(tex, sizeof(double) * z, 1, fd), err, kIOErrRead);
CopyDoubleToSingleVector((double *)tex, tex, (uint32_t)z);
fac->setTextureCoordinatesSize((uint32_t)z); /* resize for single precision */
bail:
if (err) printf("Error reading TmorphableModel\n");
return err;
}
static FaceIOErr EOSReadString(std::string &str, FILE *fd) {
FaceIOErr err = kIOErrNone;
long long z;
if (DEBUG_PARSER) printf("Reading string @ %ld (%#lx)\n", ftell(fd), ftell(fd));
BAIL_IF_FALSE(1 == fread(&z, sizeof(z), 1, fd), err, kIOErrRead);
str.resize(z);
BAIL_IF_FALSE(z == (long long)fread(&str[0], sizeof(str[0]), z, fd), err, kIOErrRead);
bail:
if (err) printf("Error reading EOS string\n");
return err;
}
static FaceIOErr EOSReadBlendShapes(FaceIOAdapter *fac, FILE *fd) {
FaceIOErr err = kIOErrNone;
size_t numShapes;
uint32_t i, modeSize, numModes;
float *modes;
long long z;
std::string name;
BAIL_IF_FALSE(1 == fread(&z, sizeof(z), 1, fd), err, kIOErrRead);
numShapes = z;
fac->setNumBlendShapes((uint32_t)numShapes);
for (i = 0; i < (uint32_t)numShapes; ++i) {
BAIL_IF_ERR(err = EOSReadString(name, fd));
fac->setBlendShapeName(i, name.c_str());
BAIL_IF_ERR(err = EOSReadModesSize(&modeSize, &numModes, fd));
modes = fac->getBlendShape(i, modeSize *= numModes);
BAIL_IF_FALSE(1 == fread(modes, modeSize * sizeof(*modes), 1, fd), err, kIOErrRead);
}
bail:
if (err) printf("Error reading TblendShapes\n");
return err;
}
struct EOSContoursReaderState {
enum {
STATE_NULL,
STATE_MODEL_CONTOUR,
STATE_RIGHT_CONTOUR,
STATE_LEFT_CONTOUR,
STATE_RIGHT_CONTOUR_ARRAY,
STATE_LEFT_CONTOUR_ARRAY,
STATE_ERROR
};
int state, nest;
FaceIOAdapter *fac;
EOSContoursReaderState() {
state = STATE_NULL;
nest = 0;
fac = nullptr;
};
};
static FaceIOErr EOSContoursOpenNode(JSONInfo *info) {
EOSContoursReaderState *st = (EOSContoursReaderState *)(info->userData);
switch (info->type) {
case kJSONObject:
++(st->nest);
break;
case kJSONArray:
++(st->nest);
switch (st->state) {
case EOSContoursReaderState::STATE_RIGHT_CONTOUR:
st->state = EOSContoursReaderState::STATE_RIGHT_CONTOUR_ARRAY;
break;
case EOSContoursReaderState::STATE_LEFT_CONTOUR:
st->state = EOSContoursReaderState::STATE_LEFT_CONTOUR_ARRAY;
break;
default:
st->state = EOSContoursReaderState::STATE_ERROR;
break;
}
break;
case kJSONNumber:
switch (st->state) {
case EOSContoursReaderState::STATE_RIGHT_CONTOUR_ARRAY:
st->fac->appendModelRightContour((uint16_t)info->number);
break;
case EOSContoursReaderState::STATE_LEFT_CONTOUR_ARRAY:
st->fac->appendModelLeftContour((uint16_t)info->number);
break;
default:
st->state = EOSContoursReaderState::STATE_ERROR;
break;
}
break;
case kJSONMember:
if (!strcmp(info->value, "model_contour"))
st->state = EOSContoursReaderState::STATE_MODEL_CONTOUR;
else if (!strcmp(info->value, "right_contour"))
st->state = EOSContoursReaderState::STATE_RIGHT_CONTOUR;
else if (!strcmp(info->value, "left_contour"))
st->state = EOSContoursReaderState::STATE_LEFT_CONTOUR;
else
st->state = EOSContoursReaderState::STATE_ERROR;
break;
}
return (EOSContoursReaderState::STATE_ERROR == st->state) ? kIOErrSyntax : kIOErrNone;
}
static FaceIOErr EOSContoursCloseNode(JSONInfo *info) {
EOSContoursReaderState *st = (EOSContoursReaderState *)(info->userData);
switch (info->type) {
case kJSONObject:
--(st->nest);
break;
case kJSONArray:
--(st->nest);
st->state = EOSContoursReaderState::STATE_NULL;
break;
}
return kIOErrNone;
}
static FaceIOErr EOSReadContours(FaceIOAdapter *fac, const char *fileName) {
JSONReader rdr(&EOSContoursOpenNode, &EOSContoursCloseNode);
EOSContoursReaderState st;
FaceIOErr err;
fac->setModelRightContourSize(0);
fac->setModelLeftContourSize(0);
st.fac = fac;
err = rdr.parse(fileName, &st);
return err;
}
struct EOSTopologyReaderState {
enum {
STATE_NULL,
STATE_EDGES,
STATE_FACES,
STATE_VERTICES,
STATE_FACES_ARRAY,
STATE_VERTICES_ARRAY,
STATE_FACES_ARRAY_OBJ,
STATE_VERTICES_ARRAY_OBJ,
STATE_ERROR
};
int state, nest;
FaceIOAdapter *fac;
EOSTopologyReaderState() {
state = STATE_NULL;
nest = 0;
fac = nullptr;
};
};
static FaceIOErr EOSTopologyOpenNode(JSONInfo *info) {
EOSTopologyReaderState *st = (EOSTopologyReaderState *)(info->userData);
switch (info->type) {
case kJSONObject:
++(st->nest);
switch (st->state) {
case EOSTopologyReaderState::STATE_FACES_ARRAY:
st->state = EOSTopologyReaderState::STATE_FACES_ARRAY_OBJ;
break;
case EOSTopologyReaderState::STATE_VERTICES_ARRAY:
st->state = EOSTopologyReaderState::STATE_VERTICES_ARRAY_OBJ;
break;
default:
break;
}
break;
case kJSONArray:
++(st->nest);
switch (st->state) {
case EOSTopologyReaderState::STATE_FACES:
st->state = EOSTopologyReaderState::STATE_FACES_ARRAY;
break;
case EOSTopologyReaderState::STATE_VERTICES:
st->state = EOSTopologyReaderState::STATE_VERTICES_ARRAY;
break;
default:
st->state = EOSTopologyReaderState::STATE_ERROR;
break;
}
break;
case kJSONNumber:
switch (st->state) {
case EOSTopologyReaderState::STATE_FACES_ARRAY:
case EOSTopologyReaderState::STATE_FACES_ARRAY_OBJ:
st->fac->appendAdjacentFace((uint16_t)info->number);
break;
case EOSTopologyReaderState::STATE_VERTICES_ARRAY:
case EOSTopologyReaderState::STATE_VERTICES_ARRAY_OBJ:
st->fac->appendAdjacentVertex((uint16_t)info->number);
break;
default:
st->state = EOSTopologyReaderState::STATE_ERROR;
break;
}
break;
case kJSONMember:
if (!strcmp(info->value, "edge_topology"))
st->state = EOSTopologyReaderState::STATE_EDGES;
else if (!strcmp(info->value, "adjacent_faces"))
st->state = EOSTopologyReaderState::STATE_FACES;
else if (!strcmp(info->value, "adjacent_vertices"))
st->state = EOSTopologyReaderState::STATE_VERTICES;
else if ((!strcmp(info->value, "value0") || !strcmp(info->value, "value1")) &&
(EOSTopologyReaderState::STATE_FACES_ARRAY_OBJ == st->state ||
EOSTopologyReaderState::STATE_VERTICES_ARRAY_OBJ == st->state)) {
} else
st->state = EOSTopologyReaderState::STATE_ERROR;
break;
}
return (EOSTopologyReaderState::STATE_ERROR == st->state) ? kIOErrSyntax : kIOErrNone;
}
static FaceIOErr EOSTopologyCloseNode(JSONInfo *info) {
EOSTopologyReaderState *st = (EOSTopologyReaderState *)(info->userData);
switch (info->type) {
case kJSONObject:
--(st->nest);
switch (st->state) {
case EOSTopologyReaderState::STATE_FACES_ARRAY_OBJ:
st->state = EOSTopologyReaderState::STATE_FACES_ARRAY;
break;
case EOSTopologyReaderState::STATE_VERTICES_ARRAY_OBJ:
st->state = EOSTopologyReaderState::STATE_VERTICES_ARRAY;
break;
default:
st->state = EOSTopologyReaderState::STATE_ERROR;
break;
}
break;
case kJSONArray:
--(st->nest);
st->state = EOSTopologyReaderState::STATE_NULL;
break;
}
return kIOErrNone;
}
static FaceIOErr EOSReadTopology(FaceIOAdapter *fac, const char *fileName) {
JSONReader rdr(&EOSTopologyOpenNode, &EOSTopologyCloseNode);
EOSTopologyReaderState st;
FaceIOErr err;
fac->setAdjacentFacesSize(0);
fac->setAdjacentVerticesSize(0);
st.fac = fac;
err = rdr.parse(fileName, &st);
return err;
}
/********************************************************************************
* API ReadEOSFaceModel API *
********************************************************************************/
FaceIOErr ReadEOSFaceModel(const char *shape, unsigned int /*ibugNumLandmarks*/, const char *blendShapes, const char *contours,
const char *topology, FaceIOAdapter *fac) {
FaceIOErr err = kIOErrNone;
FILE *fd;
if (shape) /* Shape */
{
if (!HasSuffix(shape, ".bin")) {
PrintUnknownFormatMessage(shape, "for shape");
BAIL(err, kIOErrFormat);
}
#ifndef _MSC_VER
fd = fopen(shape, "rb");
#else /* _MSC_VER */
if (0 != fopen_s(&fd, shape, "rb"))
fd = nullptr;
#endif /* _MSC_VER */
if (!fd) {
PrintIOError(shape, err = kIOErrFileOpen);
goto bail;
}
err = EOSReadMorphableModel(fac, fd);
fclose(fd);
BAIL_IF_ERR(err);
}
if (0) /* IBUG */
{
/* Insert ibug mappings reading code here */
} else {
unsigned n = sizeof(ibugMapping.landmarkMap) / sizeof(ibugMapping.landmarkMap[0][0]);
memcpy(fac->getIbugLandmarkMappings(n), &ibugMapping.landmarkMap[0][0],
n * sizeof(*fac->getIbugLandmarkMappings()));
n = sizeof(ibugMapping.rightContour) / sizeof(ibugMapping.rightContour[0]);
memcpy(fac->getIbugRightContour(n), ibugMapping.rightContour, n * sizeof(*fac->getIbugRightContour()));
n = sizeof(ibugMapping.leftContour) / sizeof(ibugMapping.leftContour[0]);
memcpy(fac->getIbugLeftContour(n), ibugMapping.leftContour, n * sizeof(*fac->getIbugLeftContour()));
}
if (blendShapes) /* Blend Shapes */
{
if (!HasSuffix(blendShapes, ".bin")) {
PrintUnknownFormatMessage(blendShapes, "for blend shapes");
BAIL(err, kIOErrFormat);
}
#ifndef _MSC_VER
fd = fopen(blendShapes, "rb");
#else /* _MSC_VER */
if (0 != fopen_s(&fd, blendShapes, "rb"))
fd = nullptr;
#endif /* _MSC_VER */
if (!fd) {
PrintIOError(blendShapes, err = kIOErrFileOpen);
goto bail;
}
err = EOSReadBlendShapes(fac, fd);
fclose(fd);
BAIL_IF_ERR(err);
}
if (contours) /* Contours */
{
if (!HasSuffix(contours, ".json")) {
PrintUnknownFormatMessage(contours, "for contours");
BAIL(err, kIOErrFormat);
}
err = EOSReadContours(fac, contours);
if (kIOErrNone != err) {
PrintIOError(contours, err);
goto bail;
}
}
if (topology) /* Topology */
{
if (!HasSuffix(topology, ".json")) {
PrintUnknownFormatMessage(topology, "for topology");
BAIL(err, kIOErrFormat);
}
err = EOSReadTopology(fac, topology);
if (kIOErrNone != err) {
PrintIOError(topology, err);
goto bail;
}
}
bail:
return err;
}
/********************************************************************************
********************************************************************************
********************************************************************************
***** JSON Output *****
********************************************************************************
********************************************************************************
********************************************************************************/
/* The maximum number of elements to print in one row when printing an array */
#define MAX_ROW_SIZE 12
static void JSONPrintModes(uint32_t size, uint32_t numModes, const float *data, JSONWriter &wtr, const char *tag) {
uint32_t modeSize = size / numModes;
uint32_t maxCols = (modeSize < MAX_ROW_SIZE) ? modeSize : MAX_ROW_SIZE;
wtr.openObject(tag);
if (modeSize > 1) wtr.writeNumber(modeSize, "mode_size");
if (numModes > 1) wtr.writeNumber(numModes, "num_modes");
wtr.writeNumericArray(size, data, maxCols, "data");
wtr.closeObject();
}
static void JSONPrintShapeModel(const FaceIOAdapter *fac, JSONWriter &wtr, const char *tag) {
wtr.openObject(tag);
JSONPrintModes(fac->getShapeMeanSize(), 1, fac->getShapeMean(), wtr, "mean"); // This is really a vector
JSONPrintModes(fac->getShapeModesSize(), fac->getShapeNumModes(), fac->getShapeModes(), wtr, "pca_basis");
JSONPrintModes(fac->getShapeEigenvaluesSize(), fac->getShapeEigenvaluesSize(), fac->getShapeEigenvalues(), wtr,
"eigenvalues");
wtr.writeNumericArray(fac->getTriangleListSize(), fac->getTriangleList(), 3, "triangles");
wtr.closeObject();
}
static void JSONPrintColorModel(const FaceIOAdapter *fac, JSONWriter &wtr, const char *tag) {
wtr.openObject(tag);
JSONPrintModes(fac->getColorMeanSize(), 1, fac->getColorMean(), wtr, "mean"); // This is really a vector
JSONPrintModes(fac->getColorModesSize(), fac->getColorNumModes(), fac->getColorModes(), wtr, "pca_basis");
JSONPrintModes(fac->getColorEigenvaluesSize(), fac->getColorEigenvaluesSize(), fac->getColorEigenvalues(), wtr,
"eigenvalues");
wtr.writeNumericArray(fac->getTriangleListSize(), fac->getTriangleList(), 3, "triangles");
wtr.closeObject();
}
static void JSONPrintMorphableModel(const FaceIOAdapter *fac, JSONWriter &wtr, const char *tag) {
wtr.openObject(tag);
JSONPrintShapeModel(fac, wtr, "shape_model");
if (fac->getColorMeanSize() + fac->getColorModesSize() + fac->getColorEigenvaluesSize() != 0)
JSONPrintColorModel(fac, wtr, "color_model"); // Don't print color unless there is something there
if (fac->getTextureCoordinatesSize())
wtr.writeNumericArray(fac->getTextureCoordinatesSize(), fac->getTextureCoordinates(), 2, "texture_coordinates");
wtr.closeObject();
}
static void JSONPrintBlendShapes(const FaceIOAdapter *fac, JSONWriter &wtr, const char *tag) {
uint32_t i, n;
wtr.openArray(tag);
for (i = 0, n = fac->getNumBlendShapes(); i < n; ++i) {
wtr.openObject(nullptr);
wtr.writeString(fac->getBlendShapeName(i), "name");
JSONPrintModes(fac->getBlendShapeSize(i), 1, fac->getBlendShape(i), wtr, "blend_shape"); // This is really a vector
wtr.closeObject();
}
wtr.closeArray();
}
static void JSONPrintIbugMappings(const FaceIOAdapter *fac, JSONWriter &wtr, const char *tag) {
uint32_t n;
wtr.openObject(tag);
wtr.writeNumericArray(fac->getIbugLandmarkMappingsSize(), fac->getIbugLandmarkMappings(), 2, "landmark_mappings");
n = (fac->getIbugRightContourSize());
wtr.writeNumericArray(n, fac->getIbugRightContour(), n, "right_contour"); // straight across
n = fac->getIbugLeftContourSize();
wtr.writeNumericArray(n, fac->getIbugLeftContour(), n, "left_contour"); // straight across
wtr.closeObject();
}
static FaceIOErr JSONPrintContours(const FaceIOAdapter *fac, JSONWriter &wtr, const char *tag) {
wtr.openObject(tag);
wtr.writeNumericArray(fac->getModelRightContourSize(), fac->getModelRightContour(),
fac->getModelRightContourSize(), "right_contour");
wtr.writeNumericArray(fac->getModelLeftContourSize(), fac->getModelLeftContour(),
fac->getModelLeftContourSize(), "left_contour");
wtr.closeObject();
return kIOErrNone;
}
static FaceIOErr JSONPrintTopology(const FaceIOAdapter *fac, JSONWriter &wtr, const char *tag) {
if (!tag) tag = "edge_topology";
wtr.openObject(tag);
wtr.writeNumericArray(fac->getAdjacentFacesSize(), fac->getAdjacentFaces(), 2, "adjacent_faces");
wtr.writeNumericArray(fac->getAdjacentVerticesSize(), fac->getAdjacentVertices(), 2, "adjacent_vertices");
wtr.closeObject();
return kIOErrNone;
}
static void JSONPrintNvlm(const FaceIOAdapter *fac, JSONWriter &wtr, const char *tag) {
uint32_t n;
wtr.openObject(tag);
wtr.writeNumericArray(fac->getNvlmLandmarksSize(), fac->getNvlmLandmarks(), 2, "landmark_mapping");
n = (fac->getNvlmRightContourSize());
wtr.writeNumericArray(n, fac->getNvlmRightContour(), n, "right_contour"); // straight across
n = fac->getNvlmLeftContourSize();
wtr.writeNumericArray(n, fac->getNvlmLeftContour(), n, "left_contour"); // straight across
wtr.closeObject();
}
static void JSONPrintPartitions(const FaceIOAdapter *fac, JSONWriter &wtr, const char *tag) {
uint32_t i, n;
wtr.openArray(tag);
for (i = 0, n = fac->getNumPartitions(); i < n; ++i) {
uint32_t partitionIndex, faceIndex, numFaces, vertexIndex, numVertices;
int32_t smoothingGroup;
const char *str;
wtr.openObject(nullptr);
partitionIndex = fac->getPartition(i, &faceIndex, &numFaces, &vertexIndex, &numVertices, &smoothingGroup);
wtr.writeNumber(partitionIndex, "partition_index");
wtr.writeNumber(faceIndex, "face_index");
wtr.writeNumber(numFaces, "num_faces");
wtr.writeNumber(vertexIndex, "vertex_index");
wtr.writeNumber(numVertices, "num_vertices");
wtr.writeNumber(smoothingGroup, "smoothing_group");
if (nullptr != (str = fac->getPartitionName(i)) && str[0])
wtr.writeString(str, "name");
if (nullptr != (str = fac->getPartitionMaterialName(i)) && str[0])
wtr.writeString(str, "material");
wtr.closeObject();
}
wtr.closeArray();
}
/********************************************************************************
* API PrintJSONFaceModel API *
********************************************************************************/
FaceIOErr PrintJSONFaceModel(FaceIOAdapter *fac, const char *file) {
FaceIOErr err;
JSONWriter wtr;
err = wtr.open(file);
if (kIOErrNone != err) {
PrintIOError(file, err);
return err;
}
wtr.openObject();
JSONPrintMorphableModel(fac, wtr, "morphable_model");
JSONPrintIbugMappings(fac, wtr, "ibug_mappings");
JSONPrintBlendShapes(fac, wtr, "blend_shapes");
JSONPrintContours(fac, wtr, "contours");
JSONPrintTopology(fac, wtr, "edge_topology");
if (fac->getNvlmLandmarksSize())
JSONPrintNvlm(fac, wtr, "nvidia_mappings");
if (fac->getNumPartitions())
JSONPrintPartitions(fac, wtr, "partitions");
wtr.closeObject();
return err;
}
Reference in New Issue View Git Blame Copy Permalink