OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

#3345 HoloLens: Refactor and extensions to VdeArrayDataPacket

Browse Source
This commit is contained in:
sigurdp
2018-09-18 23:32:20 +02:00
parent 7fb25bdbc2
commit eea5efeffd
4 changed files with 316 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
ApplicationCode/Commands/HoloLensCommands/VdeArrayDataPacket.cpp
View File

@@ -20,18 +20,44 @@
//==================================================================================================
//
//
//
//==================================================================================================
//==================================================================================================
// Binary package format/layout
//
//
//
//==================================================================================================
// packetVersion: 2 bytes
// arrayId: 4 bytes ID of this array
// elementCount: 4 bytes number of elements in array
// elementType: 1 byte data type of each element in the array(float32, uint32, uint8, int8)
// imageComponentCount: 1 byte number of image components for texture image(currently always 0 or 3)
// imageWidth: 2 bytes only used for texture images, otherwise 0
// imageHeight: 2 bytes :
// arrayData: ...
// Header offsets in bytes
static const size_t VDE_BYTEOFFSET_PACKET_VERSION = 0;
static const size_t VDE_BYTEOFFSET_ARRAY_ID = 2;
static const size_t VDE_BYTEOFFSET_ELEMENT_COUNT = 6;
static const size_t VDE_BYTEOFFSET_ELEMENT_TYPE = 10;
static const size_t VDE_BYTEOFFSET_IMAGE_COMPONENT_COUNT= 11;
static const size_t VDE_BYTEOFFSET_IMAGE_WIDTH = 12;
static const size_t VDE_BYTEOFFSET_IMAGE_HEIGHT = 14;
// Header size in bytes
static const size_t VDE_HEADER_SIZE = 2 + 4 + 4 + 1 + 1 + 2 + 2;
static const size_t VDE_PACKET_VERSION = 1;
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
VdeArrayDataPacket::VdeArrayDataPacket()
: m_packetId(-1),
: m_arrayId(-1),
m_elementType(Unknown),
m_elementCount(0)
{
@@ -40,26 +66,28 @@ VdeArrayDataPacket::VdeArrayDataPacket()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool VdeArrayDataPacket::assign(int packetId, ElementType elementType, size_t elementCount, const char* payloadPtr, size_t payloadSizeInBytes)
bool VdeArrayDataPacket::isValid() const
{
if (m_elementType != Unknown &&
m_packetBytes.size() >= VDE_HEADER_SIZE &&
m_arrayId >= 0)
{
const size_t headerByteCount = 3*sizeof(int);
const size_t totalSizeBytes = headerByteCount + payloadSizeInBytes;
m_dataBytes.resize(totalSizeBytes);
int* headerIntPtr = reinterpret_cast<int*>(m_dataBytes.data());
headerIntPtr[0] = packetId;
headerIntPtr[1] = elementType;
headerIntPtr[2] = static_cast<int>(elementCount);
m_dataBytes.insert(m_dataBytes.begin() + headerByteCount, payloadPtr, payloadPtr + payloadSizeInBytes);
m_packetId = packetId;
m_elementType = elementType;
m_elementCount = elementCount;
return true;
}
else
{
return false;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int VdeArrayDataPacket::arrayId() const
{
return m_arrayId;
}
//--------------------------------------------------------------------------------------------------
///
@@ -97,67 +125,107 @@ size_t VdeArrayDataPacket::elementCount() const
//--------------------------------------------------------------------------------------------------
const char* VdeArrayDataPacket::arrayData() const
{
const size_t headerByteCount = 3*sizeof(int);
const char* ptr = m_dataBytes.data();
return ptr + headerByteCount;
if (m_packetBytes.size() > VDE_HEADER_SIZE)
{
const char* ptr = m_packetBytes.data();
return ptr + VDE_HEADER_SIZE;
}
else
{
return nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
VdeArrayDataPacket VdeArrayDataPacket::fromFloat32Arr(int packetId, const float* srcArr, size_t srcArrElementCount)
VdeArrayDataPacket VdeArrayDataPacket::fromFloat32Arr(int arrayId, const float* srcArr, size_t srcArrElementCount)
{
size_t payloadByteCount = srcArrElementCount*sizeof(float);
const char* rawSrcPtr = reinterpret_cast<const char*>(srcArr);
VdeArrayDataPacket packet;
packet.assign(packetId, Float32, srcArrElementCount, rawSrcPtr, payloadByteCount);
packet.assign(arrayId, Float32, srcArrElementCount, rawSrcPtr, payloadByteCount);
return packet;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
VdeArrayDataPacket VdeArrayDataPacket::fromUint32Arr(int packetId, const unsigned int* srcArr, size_t srcArrElementCount)
VdeArrayDataPacket VdeArrayDataPacket::fromUint32Arr(int arrayId, const unsigned int* srcArr, size_t srcArrElementCount)
{
size_t payloadByteCount = srcArrElementCount*sizeof(unsigned int);
const char* rawSrcPtr = reinterpret_cast<const char*>(srcArr);
VdeArrayDataPacket packet;
packet.assign(packetId, Uint32, srcArrElementCount, rawSrcPtr, payloadByteCount);
packet.assign(arrayId, Uint32, srcArrElementCount, rawSrcPtr, payloadByteCount);
return packet;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
VdeArrayDataPacket VdeArrayDataPacket::fromRawPacketBuffer(const char* rawPacketBuffer, size_t bufferByteSize)
VdeArrayDataPacket VdeArrayDataPacket::fromRawPacketBuffer(const char* rawPacketBuffer, size_t bufferSize, std::string* errString)
{
const size_t headerByteCount = 3*sizeof(int);
if (bufferByteSize < headerByteCount)
if (bufferSize < VDE_HEADER_SIZE)
{
if (errString) *errString = "Buffer size is less than fixed header size";
return VdeArrayDataPacket();
}
const int* headerIntPtr = reinterpret_cast<const int*>(rawPacketBuffer);
const int packetId = headerIntPtr[0];
const ElementType elementType = static_cast<ElementType>(headerIntPtr[1]);
const size_t elementCount = headerIntPtr[2];
VdeBufferReader bufferReader(rawPacketBuffer, bufferSize);
const unsigned short packetVersion = bufferReader.getUint16(VDE_BYTEOFFSET_PACKET_VERSION);
if (packetVersion != VDE_PACKET_VERSION)
{
if (errString) *errString = "Wrong packet version";
return VdeArrayDataPacket();
}
const char* payloadPtr = rawPacketBuffer + headerByteCount;
const size_t payloadSizeInBytes = bufferByteSize - headerByteCount;
const int packetId = bufferReader.getUint32(VDE_BYTEOFFSET_ARRAY_ID);
const ElementType elementType = static_cast<ElementType>(bufferReader.getUint8(VDE_BYTEOFFSET_ELEMENT_TYPE));
const size_t elementCount = bufferReader.getUint32(VDE_BYTEOFFSET_ELEMENT_COUNT);
const char* payloadPtr = rawPacketBuffer + VDE_HEADER_SIZE;
const size_t payloadSizeInBytes = bufferSize - VDE_HEADER_SIZE;
VdeArrayDataPacket packet;
packet.assign(packetId, elementType, elementCount, payloadPtr, payloadSizeInBytes);
return packet;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool VdeArrayDataPacket::assign(int arrayId, ElementType elementType, size_t elementCount, const char* payloadPtr, size_t payloadSizeInBytes)
{
const size_t totalSizeBytes = VDE_HEADER_SIZE + payloadSizeInBytes;
m_packetBytes.resize(totalSizeBytes);
VdeBufferWriter bufferWriter(m_packetBytes.data(), m_packetBytes.size());
bufferWriter.setUint16(VDE_BYTEOFFSET_PACKET_VERSION, VDE_PACKET_VERSION);
bufferWriter.setUint32(VDE_BYTEOFFSET_ARRAY_ID, arrayId);
bufferWriter.setUint32(VDE_BYTEOFFSET_ELEMENT_COUNT, static_cast<unsigned int>(elementCount));
bufferWriter.setUint8( VDE_BYTEOFFSET_ELEMENT_TYPE, static_cast<unsigned char>(elementType));
bufferWriter.setUint16(VDE_BYTEOFFSET_IMAGE_COMPONENT_COUNT, 0);
bufferWriter.setUint16(VDE_BYTEOFFSET_IMAGE_WIDTH, 0);
bufferWriter.setUint16(VDE_BYTEOFFSET_IMAGE_HEIGHT, 0);
m_packetBytes.insert(m_packetBytes.begin() + VDE_HEADER_SIZE, payloadPtr, payloadPtr + payloadSizeInBytes);
m_arrayId = arrayId;
m_elementType = elementType;
m_elementCount = elementCount;
return true;
}
//--------------------------------------------------------------------------------------------------
/// Size of the complete packet, including header, in bytes
//--------------------------------------------------------------------------------------------------
size_t VdeArrayDataPacket::fullPacketSize() const
{
return m_dataBytes.size();
return m_packetBytes.size();
}
//--------------------------------------------------------------------------------------------------
@@ -165,6 +233,112 @@ size_t VdeArrayDataPacket::fullPacketSize() const
//--------------------------------------------------------------------------------------------------
const char* VdeArrayDataPacket::fullPacketRawPtr() const
{
return m_dataBytes.data();
return m_packetBytes.data();
}
//==================================================================================================
//
//
//
//==================================================================================================
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
VdeBufferReader::VdeBufferReader(const char* buffer, size_t bufferSize)
: m_buffer(buffer),
m_bufferSize(bufferSize)
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
unsigned int VdeBufferReader::getUint32(size_t byteOffset) const
{
if (byteOffset + sizeof(unsigned int) <= m_bufferSize)
{
return *reinterpret_cast<const unsigned int*>(&m_buffer[byteOffset]);
}
return 0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
unsigned short VdeBufferReader::getUint16(size_t byteOffset) const
{
if (byteOffset + sizeof(unsigned short) <= m_bufferSize)
{
return *reinterpret_cast<const unsigned short*>(&m_buffer[byteOffset]);
}
return 0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
unsigned char VdeBufferReader::getUint8(size_t byteOffset) const
{
if (byteOffset + 1 <= m_bufferSize)
{
return *reinterpret_cast<const unsigned char*>(&m_buffer[byteOffset]);
}
return 0;
}
//==================================================================================================
//
//
//
//==================================================================================================
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
VdeBufferWriter::VdeBufferWriter(char* buffer, size_t bufferSize)
: m_buffer(buffer),
m_bufferSize(bufferSize)
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void VdeBufferWriter::setUint32(size_t byteOffset, unsigned int val)
{
if (byteOffset + sizeof(unsigned int) <= m_bufferSize)
{
*reinterpret_cast<unsigned int*>(&m_buffer[byteOffset]) = val;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void VdeBufferWriter::setUint16(size_t byteOffset, unsigned short val)
{
if (byteOffset + sizeof(unsigned short) <= m_bufferSize)
{
*reinterpret_cast<unsigned short*>(&m_buffer[byteOffset]) = val;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void VdeBufferWriter::setUint8(size_t byteOffset, unsigned char val)
{
if (byteOffset + 1 <= m_bufferSize)
{
*reinterpret_cast<unsigned char*>(&m_buffer[byteOffset]) = val;
}
}

65
ApplicationCode/Commands/HoloLensCommands/VdeArrayDataPacket.h
View File

@@ -20,6 +20,7 @@
#include <cstddef>
#include <vector>
#include <string>
//==================================================================================================
@@ -33,11 +34,16 @@ public:
enum ElementType
{
Unknown = 0,
Uint32,
Float32
Uint32 = 1,
Float32 = 2
};
public:
VdeArrayDataPacket();
bool isValid() const;
int arrayId() const;
ElementType elementType() const;
size_t elementSize() const;
size_t elementCount() const;
@@ -46,21 +52,60 @@ public:
size_t fullPacketSize() const;
const char* fullPacketRawPtr() const;
static VdeArrayDataPacket fromFloat32Arr(int packetId, const float* srcArr, size_t srcArrElementCount);
static VdeArrayDataPacket fromUint32Arr(int packetId, const unsigned int* srcArr, size_t srcArrElementCount);
static VdeArrayDataPacket fromFloat32Arr(int arrayId, const float* srcArr, size_t srcArrElementCount);
static VdeArrayDataPacket fromUint32Arr(int arrayId, const unsigned int* srcArr, size_t srcArrElementCount);
static VdeArrayDataPacket fromRawPacketBuffer(const char* rawPacketBuffer, size_t bufferByteSize);
static VdeArrayDataPacket fromRawPacketBuffer(const char* rawPacketBuffer, size_t bufferSize, std::string* errString);
private:
VdeArrayDataPacket();
bool assign(int packetId, ElementType elementType, size_t elementCount, const char* payloadPtr, size_t payloadSizeInBytes);
bool assign(int arrayId, ElementType elementType, size_t elementCount, const char* payloadPtr, size_t payloadSizeInBytes);
private:
int m_packetId;
int m_arrayId;
ElementType m_elementType;
size_t m_elementCount;
std::vector<char> m_dataBytes;
std::vector<char> m_packetBytes;
};
//==================================================================================================
//
//
//
//==================================================================================================
class VdeBufferReader
{
public:
VdeBufferReader(const char* buffer, size_t bufferSize);
unsigned int getUint32(size_t byteOffset) const;
unsigned short getUint16(size_t byteOffset) const;
unsigned char getUint8(size_t byteOffset) const;
private:
const char* m_buffer;
const size_t m_bufferSize;
};
//==================================================================================================
//
//
//
//==================================================================================================
class VdeBufferWriter
{
public:
VdeBufferWriter(char* buffer, size_t bufferSize);
void setUint32(size_t byteOffset, unsigned int val);
void setUint16(size_t byteOffset, unsigned short val);
void setUint8(size_t byteOffset, unsigned char val);
private:
char* m_buffer;
const size_t m_bufferSize;
};

50
ApplicationCode/Commands/HoloLensCommands/VdeFileExporter.cpp
View File

@@ -62,6 +62,16 @@ bool VdeFileExporter::exportViewContents(const RimGridView& view)
std::vector<VdeMesh> meshArr;
std::vector<cvf::Color3f> colorArr;
colorArr.push_back(cvf::Color3f::fromByteColor( 81, 134, 148));
colorArr.push_back(cvf::Color3f::fromByteColor(212, 158, 97));
colorArr.push_back(cvf::Color3f::fromByteColor(217, 82, 28));
colorArr.push_back(cvf::Color3f::fromByteColor(212, 148, 138));
colorArr.push_back(cvf::Color3f::fromByteColor(115, 173, 181));
colorArr.push_back(cvf::Color3f::fromByteColor(125, 84, 56));
colorArr.push_back(cvf::Color3f::fromByteColor(206, 193, 55));
colorArr.push_back(cvf::Color3f::fromByteColor(252, 209, 158));
for (size_t i = 0; i < allPartsColl.size(); i++)
{
const cvf::Part* part = allPartsColl.at(i);
@@ -70,6 +80,7 @@ bool VdeFileExporter::exportViewContents(const RimGridView& view)
VdeMesh mesh;
if (extractMeshFromPart(view, *part, &mesh))
{
mesh.color = colorArr[i % colorArr.size()];
meshArr.push_back(mesh);
}
}
@@ -118,7 +129,7 @@ bool VdeFileExporter::exportViewContents(const RimGridView& view)
// Testing decoding
{
VdeArrayDataPacket testPacket = VdeArrayDataPacket::fromRawPacketBuffer(dataPacket.fullPacketRawPtr(), dataPacket.fullPacketSize());
VdeArrayDataPacket testPacket = VdeArrayDataPacket::fromRawPacketBuffer(dataPacket.fullPacketRawPtr(), dataPacket.fullPacketSize(), nullptr);
CVF_ASSERT(dataPacket.elementCount() == testPacket.elementCount());
CVF_ASSERT(dataPacket.elementSize() == testPacket.elementSize());
CVF_ASSERT(dataPacket.elementType() == testPacket.elementType());
@@ -147,7 +158,7 @@ bool VdeFileExporter::exportViewContents(const RimGridView& view)
// Testing decoding
{
VdeArrayDataPacket testPacket = VdeArrayDataPacket::fromRawPacketBuffer(dataPacket.fullPacketRawPtr(), dataPacket.fullPacketSize());
VdeArrayDataPacket testPacket = VdeArrayDataPacket::fromRawPacketBuffer(dataPacket.fullPacketRawPtr(), dataPacket.fullPacketSize(), nullptr);
CVF_ASSERT(dataPacket.elementCount() == testPacket.elementCount());
CVF_ASSERT(dataPacket.elementSize() == testPacket.elementSize());
CVF_ASSERT(dataPacket.elementType() == testPacket.elementType());
@@ -164,29 +175,42 @@ bool VdeFileExporter::exportViewContents(const RimGridView& view)
{
QVariantList meshVariantList;
QVariantList jsonMeshMetaList;
for (size_t i = 0; i < meshArr.size(); i++)
{
const VdeMesh& mesh = meshArr[i];
const MeshIds& meshIds = meshIdsArr[i];
QMap<QString, QVariant> meshMeta;
meshMeta["meshSourceObjType"] = mesh.meshSourceObjTypeStr;
meshMeta["meshSourceObjName"] = mesh.meshSourceObjName;
meshMeta["verticesPerPrimitive"] = mesh.verticesPerPrimitive;
meshMeta["vertexArrId"] = meshIds.vertexArrId;
meshMeta["connArrId"] = meshIds.connArrId;
QMap<QString, QVariant> jsonMeshMeta;
jsonMeshMeta["meshSourceObjType"] = mesh.meshSourceObjTypeStr;
jsonMeshMeta["meshSourceObjName"] = mesh.meshSourceObjName;
meshVariantList.push_back(meshMeta);
jsonMeshMeta["verticesPerPrimitive"] = mesh.verticesPerPrimitive;
jsonMeshMeta["vertexArrId"] = meshIds.vertexArrId;
jsonMeshMeta["connArrId"] = meshIds.connArrId;
{
QMap<QString, QVariant> jsonColor;
jsonColor["r"] = mesh.color.r();
jsonColor["g"] = mesh.color.g();
jsonColor["b"] = mesh.color.b();
jsonMeshMeta["color"] = jsonColor;
}
QMap<QString, QVariant> modelMetaJson;
modelMetaJson["meshArr"] = meshVariantList;
jsonMeshMeta["opacity"] = 1.0;
jsonMeshMetaList.push_back(jsonMeshMeta);
}
QMap<QString, QVariant> jsonModelMeta;
jsonModelMeta["modelName"] = "ResInsightExport";
jsonModelMeta["meshArr"] = jsonMeshMetaList;
ResInsightInternalJson::Json jsonCodec;
const bool prettifyJson = true;
QByteArray jsonStr = jsonCodec.encode(modelMetaJson, prettifyJson).toLatin1();
QByteArray jsonStr = jsonCodec.encode(jsonModelMeta, prettifyJson).toLatin1();
QString jsonFileName = outputDir.absoluteFilePath("modelMeta.json");
QFile file(jsonFileName);

2
ApplicationCode/Commands/HoloLensCommands/VdeFileExporter.h
View File

@@ -43,6 +43,8 @@ struct VdeMesh
QString meshSourceObjTypeStr;
QString meshSourceObjName;
cvf::Color3f color;
int verticesPerPrimitive;
cvf::cref<cvf::Vec3fArray> vertexArr;
std::vector<cvf::uint> connArr;