#3345 HoloLens: Refactor and extensions to VdeArrayDataPacket

ApplicationCode/Commands/HoloLensCommands/VdeArrayDataPacket.cpp

@@ -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,25 +66,27 @@ VdeArrayDataPacket::VdeArrayDataPacket()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool VdeArrayDataPacket::assign(int packetId, ElementType elementType, size_t elementCount, const char* payloadPtr, size_t payloadSizeInBytes)
+bool VdeArrayDataPacket::isValid() const
 {
-    const size_t headerByteCount = 3*sizeof(int);
+    if (m_elementType != Unknown && 
-    const size_t totalSizeBytes = headerByteCount + payloadSizeInBytes;
+        m_packetBytes.size() >= VDE_HEADER_SIZE &&
+        m_arrayId >= 0)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
 
-    m_dataBytes.resize(totalSizeBytes);
+}
 
-    int* headerIntPtr = reinterpret_cast<int*>(m_dataBytes.data());
+//--------------------------------------------------------------------------------------------------
-    headerIntPtr[0] = packetId;
+///
-    headerIntPtr[1] = elementType;
+//--------------------------------------------------------------------------------------------------
-    headerIntPtr[2] = static_cast<int>(elementCount);
+int VdeArrayDataPacket::arrayId() const
-
+{
-    m_dataBytes.insert(m_dataBytes.begin() + headerByteCount, payloadPtr, payloadPtr + payloadSizeInBytes);
+    return m_arrayId;
-
-    m_packetId = packetId;
-    m_elementType = elementType;
-    m_elementCount = elementCount;
-
-    return true;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -97,67 +125,107 @@ size_t VdeArrayDataPacket::elementCount() const
 //--------------------------------------------------------------------------------------------------
 const char* VdeArrayDataPacket::arrayData() const
 {
-    const size_t headerByteCount = 3*sizeof(int);
+    if (m_packetBytes.size() > VDE_HEADER_SIZE)
-    const char* ptr = m_dataBytes.data();
+    {
-    return ptr + headerByteCount;
+        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 (bufferSize < VDE_HEADER_SIZE)
-    if (bufferByteSize < headerByteCount)
     {
+        if (errString) *errString = "Buffer size is less than fixed header size";
         return VdeArrayDataPacket();
     }
 
-    const int* headerIntPtr = reinterpret_cast<const int*>(rawPacketBuffer);
+    VdeBufferReader bufferReader(rawPacketBuffer, bufferSize);
-    const int packetId = headerIntPtr[0];
+    const unsigned short packetVersion = bufferReader.getUint16(VDE_BYTEOFFSET_PACKET_VERSION);
-    const ElementType elementType = static_cast<ElementType>(headerIntPtr[1]);
+    if (packetVersion != VDE_PACKET_VERSION)
-    const size_t elementCount = headerIntPtr[2];
+    {
+        if (errString) *errString = "Wrong packet version";
+        return VdeArrayDataPacket();
+    }
 
-    const char* payloadPtr = rawPacketBuffer + headerByteCount;
+    const int packetId              = bufferReader.getUint32(VDE_BYTEOFFSET_ARRAY_ID);
-    const size_t payloadSizeInBytes = bufferByteSize - headerByteCount;
+    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;
+    }
 }
 

ApplicationCode/Commands/HoloLensCommands/VdeArrayDataPacket.h

@@ -20,6 +20,7 @@
 
 #include <cstddef>
 #include <vector>
+#include <string>
 
 
 //==================================================================================================
@@ -33,34 +34,78 @@ public:
     enum ElementType
     {
         Unknown = 0,
-        Uint32,
+        Uint32  = 1,
-        Float32
+        Float32 = 2
     };
 
 public:
-    ElementType             elementType() const;
-    size_t                  elementSize() const;
-    size_t                  elementCount() const;
-    const char*             arrayData() const;
-
-    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  fromRawPacketBuffer(const char* rawPacketBuffer, size_t bufferByteSize);
-
-private:
     VdeArrayDataPacket();
 
-    bool    assign(int packetId, ElementType elementType, size_t elementCount, const char* payloadPtr, size_t payloadSizeInBytes);
+    bool                        isValid() const;
+    int                         arrayId() const;
+
+    ElementType                 elementType() const;
+    size_t                      elementSize() const;
+    size_t                      elementCount() const;
+    const char*                 arrayData() const;
+
+    size_t                      fullPacketSize() const;
+    const char*                 fullPacketRawPtr() const;
+
+    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 bufferSize, std::string* errString);
 
 private:
-    int                 m_packetId;
+    bool    assign(int arrayId, ElementType elementType, size_t elementCount, const char* payloadPtr, size_t payloadSizeInBytes);
+
+private:
+    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;
 };
 

ApplicationCode/Commands/HoloLensCommands/VdeFileExporter.cpp

@@ -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;
+            QMap<QString, QVariant> jsonMeshMeta;
-            meshMeta["meshSourceObjType"] = mesh.meshSourceObjTypeStr;
+            jsonMeshMeta["meshSourceObjType"] = mesh.meshSourceObjTypeStr;
-            meshMeta["meshSourceObjName"] = mesh.meshSourceObjName;
+            jsonMeshMeta["meshSourceObjName"] = mesh.meshSourceObjName;
-            meshMeta["verticesPerPrimitive"] = mesh.verticesPerPrimitive;
-            meshMeta["vertexArrId"] = meshIds.vertexArrId;
-            meshMeta["connArrId"] = meshIds.connArrId;
 
-            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;
+            }
+
+            jsonMeshMeta["opacity"] = 1.0;
+
+            jsonMeshMetaList.push_back(jsonMeshMeta);
         }
 
-        QMap<QString, QVariant> modelMetaJson;
+        QMap<QString, QVariant> jsonModelMeta;
-        modelMetaJson["meshArr"] = meshVariantList;
+        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);

ApplicationCode/Commands/HoloLensCommands/VdeFileExporter.h

@@ -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;