diff options
Diffstat (limited to 'LibOVR/Src/Util/Util_MatFile.cpp')
| -rw-r--r-- | LibOVR/Src/Util/Util_MatFile.cpp | 496 |
1 files changed, 496 insertions, 0 deletions
diff --git a/LibOVR/Src/Util/Util_MatFile.cpp b/LibOVR/Src/Util/Util_MatFile.cpp new file mode 100644 index 0000000..f17e269 --- /dev/null +++ b/LibOVR/Src/Util/Util_MatFile.cpp @@ -0,0 +1,496 @@ +/************************************************************************************ + +Filename : Util_MatFile.cpp +Content : Matlab .MAT file access functions +Created : June 1, 2014 +Authors : Neil Konzen + +Copyright : Copyright 2014 Oculus VR, Inc. All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (the "License"); +you may not use the Oculus VR Rift SDK except in compliance with the License, +which is provided at the time of installation or download, or which +otherwise accompanies this software in either electronic or hard copy form. + +You may obtain a copy of the License at + +http://www.oculusvr.com/licenses/LICENSE-3.2 + +Unless required by applicable law or agreed to in writing, the Oculus VR SDK +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +*************************************************************************************/ + +#include "Util_MatFile.h" + +#include "Kernel/OVR_Types.h" +#include "Kernel/OVR_Alg.h" +#include "Kernel/OVR_Std.h" + +OVR_DISABLE_MSVC_WARNING(4996) // 'fopen': This function or variable may be unsafe. Consider using fopen_s inst + + +namespace OVR { namespace Util { + +using namespace OVR::Alg; + + +// Data structures relating to MATLAB .MAT binary files +#define FX_FORM_IEEE_LE 0000u +#define FX_FORM_IEEE_BE 1000u +#define FX_FORM_VAX_D_FLOAT 2000u +#define FX_FORM_VAX_G_FLOAT 3000u +#define FX_FORM_CRAY 4000u +#define FX_FORM(type) ((((type) / 1000u) % 10u) * 1000u) + +#define FX_PREC_UINT8 50u +#define FX_PREC_INTU 40u +#define FX_PREC_INTS 30u +#define FX_PREC_LONG 20u +#define FX_PREC_SINGLE 10u +#define FX_PREC_DOUBLE 00u +#define FX_PREC(type) ((((type) / 10u) % 10u) * 10u) + +// Note that the elements of a text matrix are stored as floating-point numbers +// between 0 and 255 representing ASCII-encoded characters. +#define FX_MAT_NUMERIC 0u +#define FX_MAT_TEXT 1u +#define FX_MAT_SPARSE 2u +#define FX_MAT(type) ((type) % 10u) + +struct Fmatrix +{ + uint32_t type; // Type - see #defines + uint32_t mrows; // Row dimension - NOTE: Column dimension for C Arrays! + uint32_t ncols; // Column dimension - NOTE: Row dimension for C Arrays! + uint32_t imagf; // 1=complex, 0=real + uint32_t namelen; // length including zero terminator +}; + + +uint32_t MatFile::GetMatlabType(ValueType type, size_t& valueSize) +{ + switch (type) + { + case ByteValue: valueSize = sizeof(uint8_t); return FX_PREC_UINT8; + case UInt16Value: valueSize = sizeof(uint16_t); return FX_PREC_INTU; + case Int16Value: valueSize = sizeof(int16_t); return FX_PREC_INTS; + case UInt32Value: valueSize = sizeof(uint32_t); return FX_PREC_LONG; // Not directly supported by matlab! + case Int32Value: valueSize = sizeof(int32_t); return FX_PREC_LONG; + case FloatValue: valueSize = sizeof(float); return FX_PREC_SINGLE; + case DoubleValue: valueSize = sizeof(double); return FX_PREC_DOUBLE; + case StringValue: valueSize = sizeof(char); return FX_MAT_TEXT; // special case for string arrays + default: + OVR_ASSERT(false); + valueSize = 0; + return 0; + } +} + +MatFile::ValueType MatFile::GetValueType(uint32_t matlabType, size_t& valueSize) +{ + switch (matlabType) + { + case FX_PREC_UINT8: valueSize = sizeof(uint8_t); return ByteValue; + case FX_PREC_INTU: valueSize = sizeof(uint16_t); return UInt16Value; + case FX_PREC_INTS: valueSize = sizeof(int16_t); return Int16Value; + case FX_PREC_LONG: valueSize = sizeof(int32_t); return Int32Value; + case FX_PREC_SINGLE: valueSize = sizeof(float); return FloatValue; + case FX_PREC_DOUBLE: valueSize = sizeof(double); return DoubleValue; + case FX_MAT_TEXT: valueSize = sizeof(char); return StringValue; + default: + OVR_ASSERT(false); + valueSize = 0; + return UnknownValue; + } +} + +MatFile::MatFile(void) +{ + m_f = NULL; +} + +MatFile::~MatFile(void) +{ + if (m_f) + fclose(m_f); + m_f = NULL; +} + +// Matlab arrays are stored column-major, while C/C++ arrays are stored row-major. +// This means that a C array appears to Matlab transposed, and vice versa. +// To deal with this we swap the row and column values stored in the Matlab matrix header. + +bool MatFile::Open(const char* pszFile, bool write) +{ + OVR_ASSERT(!m_f); + m_f = fopen(pszFile, write ? "wb" : "rb"); + return (m_f != nullptr); +} + +void MatFile::Close() +{ + if (m_f) + { + fclose(m_f); + m_f = NULL; + } +} + +int MatFile::ReadString(const char* name, char* text, size_t maxTextSize) +{ + int rows, cols; + ValueType valueType; + + maxTextSize = Alg::Min(maxTextSize, INT_MAX/sizeof(double)/2); + + if (!GetMatrixInfo(name, valueType, rows, cols)) + return 0; + + if (valueType != StringValue) + return 0; + + int count = rows * cols; // character count, not including zero terminator + + double* doubles = new double[count]; + ReadMatrixValues(doubles, StringValue, count, 1); + + if (maxTextSize > 0 && count > 0) + { + count = (int)Alg::Min(count, (int)(maxTextSize-1)); + for (int i = 0; i < count; i++) + text[i] = (char)doubles[i]; + text[count] = 0; // Always zero terminate + } + + delete[] doubles; + + return count; +} + +bool MatFile::WriteString(const char* name, const char* string) +{ + int length = (int)Alg::Min(strlen(string), INT_MAX/sizeof(double)/2); + + double* doubles = new double[length]; + for (int i = 0; i < length; i++) + doubles[i] = (double)((unsigned char)string[i]); + + bool ok = WriteMatrix(name, doubles, StringValue, (int)length, 1); + + delete[] doubles; + + return ok; +} + +void* MatFile::ReadMatrix(const char* name, ValueType valueType, int& rows, int& cols) +{ + ValueType fileValueType; + if (!GetMatrixInfo(name, fileValueType, rows, cols)) + return NULL; + + int valueCount = rows * cols; + + void* values = NULL; + switch (fileValueType) + { + case StringValue: // Text matrices are stored as doubles + case DoubleValue: + values = new double[valueCount]; + break; + case FloatValue: + values = new float[valueCount]; + break; + case ByteValue: + values = new uint8_t[valueCount]; + break; + case Int16Value: + values = new int16_t[valueCount]; + break; + case UInt16Value: + values = new uint16_t[valueCount]; + break; + case Int32Value: + /*case UInt32Value: -- not directly supported by matlab -v4 files */ + values = new int32_t[valueCount]; + break; + default: + OVR_ASSERT(false); + return NULL; + } + + bool ok = ReadMatrixValues(values, fileValueType, rows, cols); + + if (ok) + values = ConvertVector(values, valueCount, fileValueType, valueType); + + if (!ok) + { + delete[] (char*)values; + values = NULL; + } + + OVR_ASSERT(values); + return values; +} + +void* MatFile::ConvertVector(void* fromValues, int valueCount, ValueType fromType, ValueType toType) +{ + // Special case: Always convert characters stored as doubles to a char array + if (fromType == StringValue) + fromType = DoubleValue; + + if (fromType == toType) + return fromValues; + + // UInt32 values are stored as Int32 values by Matlab + if (fromType == Int32Value && toType == UInt32Value) + return fromValues; + + // When a .mat file is saved by Matlab, many datatypes are converted to double. + // We support conversion of doubles to some other types: float, long, byte, char + // and strings and floats to doubles. + // convert singles to doubles + bool ok = true; + if (fromType == DoubleValue) + { + const double* fromDoubles = (const double*)fromValues; + if (toType == FloatValue) + { + float* newValues = new float[valueCount]; + for (int i = 0; i < valueCount; i++) + newValues[i] = (float)fromDoubles[i]; + delete[] (char*)fromValues; + fromValues = newValues; + } + else if (toType == Int32Value) + { + int32_t* newValues = new int32_t[valueCount]; + for (int i = 0; i < valueCount; i++) + newValues[i] = (int32_t)fromDoubles[i]; + delete[] (char*)fromValues; + fromValues = newValues; + } + else if (toType == UInt32Value) + { + uint32_t* newValues = new uint32_t[valueCount]; + for (int i = 0; i < valueCount; i++) + newValues[i] = (uint32_t)fromDoubles[i]; + delete[] (char*)fromValues; + fromValues = newValues; + } + else if (toType == Int16Value) + { + int16_t* newValues = new int16_t[valueCount]; + for (int i = 0; i < valueCount; i++) + newValues[i] = (int16_t)fromDoubles[i]; + delete[] (char*)fromValues; + fromValues = newValues; + } + else if (toType == UInt16Value) + { + uint16_t* newValues = new uint16_t[valueCount]; + for (int i = 0; i < valueCount; i++) + newValues[i] = (uint16_t)fromDoubles[i]; + delete[] (char*)fromValues; + fromValues = newValues; + } + else if (toType == ByteValue) + { + uint8_t* newValues = new uint8_t[valueCount]; + for (int i = 0; i < valueCount; i++) + newValues[i] = (uint8_t)fromDoubles[i]; + delete[] (char*)fromValues; + fromValues = newValues; + } + else if (toType == StringValue) + { + char* newValues = new char[valueCount]; + for (int i = 0; i < valueCount; i++) + newValues[i] = (char)fromDoubles[i]; + delete[] (char*)fromValues; + fromValues = newValues; + } + else + { + // unsupported type conversion + ok = false; + } + } + else + { + ok = false; // only conversions from doubles supported + } + + if (!ok) + { + OVR_ASSERT(false); + delete[] (char*)fromValues; + fromValues = NULL; + } + + return fromValues; +} + +bool MatFile::GetMatrixInfo(const char* name, ValueType& valueType, int& rows, int& cols) +{ + OVR_ASSERT(m_f); + fseek(m_f, 0, SEEK_SET); // rewind to start of file + + static const int maxVarNameLen = 255; + char varName[maxVarNameLen+1]; + + while (ReadMatrixInfo(varName, maxVarNameLen, valueType, rows, cols)) + { + if (OVR_stricmp(name, varName) == 0) + return true; + // skip over data to next one + ReadMatrixValues(NULL, valueType, rows, cols); + } + + return false; +} + +bool MatFile::ReadMatrixInfo(char name[], size_t maxNameSize, ValueType& valueType, int& rows, int& cols) +{ + if (name && maxNameSize > 0) + name[0] = 0; + + valueType = UnknownValue; + rows = 0; + cols = 0; + + OVR_ASSERT(m_f); + if (!m_f) + return false; + + Fmatrix header; + if (fread(&header, sizeof(header), 1, m_f) != 1) + return false; + + // Read transpose of row and column values stored in the file + cols = header.mrows; + rows = header.ncols; + + if (FX_FORM(header.type) != FX_FORM_IEEE_LE) + { + OVR_ASSERT(false); + return false; + } + + // Imaginary not supported + if (header.imagf != 0) + { + OVR_ASSERT(false); + return false; + } + + // sparse matrices not supported + if (FX_MAT(header.type) == FX_MAT_SPARSE) + { + OVR_ASSERT(false); + return false; + } + + // Special case for strings as text matrixes: they are stored as doubles(!) + if (FX_MAT(header.type) == FX_MAT_TEXT) + { + valueType = StringValue; + } + else + { + // only numeric types supported + if (FX_MAT(header.type) != FX_MAT_NUMERIC) + { + OVR_ASSERT(false); + return false; + } + size_t valueSize; + valueType = GetValueType(FX_PREC(header.type), valueSize); + } + + // Read in name + OVR_ASSERT(maxNameSize >= header.namelen); + if (maxNameSize < header.namelen) + return false; + + if (fread(name, sizeof(char), header.namelen, m_f) != header.namelen) + return false; + + return true; +} + +bool MatFile::ReadMatrixValues(void* values, ValueType valueType, int rows, int cols) +{ + OVR_ASSERT(m_f); + if (!m_f) + return false; + + OVR_ASSERT(rows*cols > 0); + + size_t valueCount = (size_t)(rows * cols); + size_t valueSize = 0; + GetMatlabType(valueType, valueSize); + if (valueSize == 0) + return false; + + // If no values pointer specified, skip over data without reading + if (!values) + { + if (fseek(m_f, (long)(valueSize * valueCount), SEEK_CUR) != 0) + return false; + } + else + { + if (fread(values, valueSize, valueCount, m_f) != valueCount) + return false; + } + + return true; +} + +bool MatFile::WriteMatrix(const char* name, const void* values, ValueType valueType, int rows, int cols) +{ + if (!m_f) + return false; + + OVR_ASSERT(rows*cols > 0); + + size_t valueCount = (size_t)(rows * cols); + size_t valueSize = 0; + uint32_t matlabType = GetMatlabType(valueType, valueSize); + if (valueSize == 0) + return false; + + Fmatrix header; + if (valueType == StringValue) + { + header.type = (FX_FORM_IEEE_LE + FX_MAT_TEXT); + } + else + { + header.type = (FX_FORM_IEEE_LE + FX_MAT_NUMERIC) + matlabType; + } + + // NOTE: We store transposed dimensions! + header.mrows = cols; + header.ncols = rows; + header.imagf = 0; + header.namelen = (uint32_t)(strlen(name) + 1); + OVR_ASSERT(header.namelen > 1); + + if (fwrite(&header, sizeof(header), 1, m_f) != 1) + return false; + if (fwrite(name, sizeof(char), header.namelen, m_f) != header.namelen) + return false; + if (fwrite(values, valueSize, valueCount, m_f) != valueCount) + return false; + + return true; +} + + +}} // namespace OVR::Util |