mdal_memory_data_model.hpp

/*
 MDAL - Mesh Data Abstraction Library (MIT License)
 Copyright (C) 2018 Peter Petrik (zilolv at gmail dot com)
*/
 
#ifndef MDAL_MEMORY_DATA_MODEL_HPP
#define MDAL_MEMORY_DATA_MODEL_HPP
 
#include <stddef.h>
#include <assert.h>
#include <vector>
#include <memory>
#include <map>
#include <string>
#include "mdal.h"
#include "mdal_data_model.hpp"
 
namespace MDAL
{
  class MemoryMesh;
 
  typedef struct VertexType
  {
    double x = std::numeric_limits<double>::quiet_NaN();
    double y = std::numeric_limits<double>::quiet_NaN();
    double z = 0.0; // Bed elevation
 
  } Vertex;
 
  typedef struct
  {
    size_t startVertex;
    size_t endVertex;
  } Edge;
 
  typedef std::vector<size_t> Face;
  typedef std::vector<Vertex> Vertices;
  typedef std::vector<Edge> Edges;
  typedef std::vector<Face> Faces;
 
  class MemoryDataset2D: public Dataset2D
  {
    public:
      MemoryDataset2D( DatasetGroup *grp, bool hasActiveFlag = false );
      ~MemoryDataset2D() override;
 
      size_t scalarData( size_t indexStart, size_t count, double *buffer ) override;
      size_t vectorData( size_t indexStart, size_t count, double *buffer ) override;
 
      size_t activeData( size_t indexStart, size_t count, int *buffer ) override;
 
      void activateFaces( MDAL::MemoryMesh *mesh );
 
      void setActive( size_t index, int stat )
      {
        assert( supportsActiveFlag() );
        assert( mActive.size() > index );
        mActive[index] = stat;
      }
 
      void setActive( const int *activeBuffer );
 
      int active( size_t index ) const
      {
        assert( supportsActiveFlag() );
        assert( mActive.size() > index );
        return mActive[index];
      }
 
      void setScalarValue( size_t index, double value )
      {
        assert( mValues.size() > index );
        assert( group()->isScalar() );
        mValues[index] = value;
      }
 
      void setVectorValue( size_t index, double x, double y )
      {
        assert( mValues.size() > 2 * index + 1 );
        assert( !group()->isScalar() );
        mValues[2 * index] = x;
        mValues[2 * index + 1] = y;
      }
 
      void setValueX( size_t index, double x )
      {
        assert( mValues.size() > 2 * index );
        assert( !group()->isScalar() );
 
        mValues[2 * index] = x;
      }
 
      void setValueY( size_t index, double x )
      {
        assert( mValues.size() > 2 * index + 1 );
        assert( !group()->isScalar() );
        mValues[2 * index + 1] = x;
      }
 
      double valueX( size_t index ) const
      {
        assert( mValues.size() > 2 * index + 1 );
        assert( !group()->isScalar() );
        return mValues[2 * index];
      }
 
      double valueY( size_t index ) const
      {
        assert( mValues.size() > 2 * index + 1 );
        assert( !group()->isScalar() );
        return mValues[2 * index + 1];
      }
 
      double scalarValue( size_t index ) const
      {
        assert( mValues.size() > index );
        assert( group()->isScalar() );
        return mValues[index];
      }
 
      double *values()
      {
        return mValues.data();
      }
 
    private:
      std::vector<double> mValues;
 
      std::vector<int> mActive;
  };
 
  class MemoryDataset3D: public Dataset3D
  {
    public:
 
      MemoryDataset3D(
        DatasetGroup *grp,
        size_t volumes,
        size_t maxVerticalLevelCount,
        const int *verticalLevelCounts,
        const double *verticalExtrusions
      );
 
      ~MemoryDataset3D() override;
 
 
      void setScalarValue( size_t index, double value )
      {
        assert( mValues.size() > index );
        assert( group()->isScalar() );
        mValues[index] = value;
      }
 
      void setVectorValue( size_t index, double x, double y )
      {
        assert( mValues.size() > 2 * index + 1 );
        assert( !group()->isScalar() );
        mValues[2 * index] = x;
        mValues[2 * index + 1] = y;
      }
 
      void setValueX( size_t index, double x )
      {
        assert( mValues.size() > 2 * index );
        assert( !group()->isScalar() );
 
        mValues[2 * index] = x;
      }
 
      void setValueY( size_t index, double x )
      {
        assert( mValues.size() > 2 * index + 1 );
        assert( !group()->isScalar() );
        mValues[2 * index + 1] = x;
      }
 
      double valueX( size_t index ) const
      {
        assert( mValues.size() > 2 * index + 1 );
        assert( !group()->isScalar() );
        return mValues[2 * index];
      }
 
      double valueY( size_t index ) const
      {
        assert( mValues.size() > 2 * index + 1 );
        assert( !group()->isScalar() );
        return mValues[2 * index + 1];
      }
 
      double scalarValue( size_t index ) const
      {
        assert( mValues.size() > index );
        assert( group()->isScalar() );
        return mValues[index];
      }
 
      void updateIndices();
 
      double *values()
      {
        return mValues.data();
      }
 
      size_t verticalLevelCountData( size_t indexStart, size_t count, int *buffer ) override;
      size_t verticalLevelData( size_t indexStart, size_t count, double *buffer ) override;
      size_t faceToVolumeData( size_t indexStart, size_t count, int *buffer ) override;
      size_t scalarVolumesData( size_t indexStart, size_t count, double *buffer ) override;
      size_t vectorVolumesData( size_t indexStart, size_t count, double *buffer ) override;
 
    private:
      std::vector<double> mValues;
 
      std::vector<int> mFaceToVolume;
 
      std::vector<int> mVerticalLevelCounts;
 
      std::vector<double> mVerticalExtrusions;
  };
 
  class MemoryMesh: public Mesh
  {
    public:
      MemoryMesh( const std::string &driverName,
                  size_t faceVerticesMaximumCount,
                  const std::string &uri );
 
      ~MemoryMesh() override;
 
      std::unique_ptr<MDAL::MeshVertexIterator> readVertices() override;
      std::unique_ptr<MDAL::MeshEdgeIterator> readEdges() override;
      std::unique_ptr<MDAL::MeshFaceIterator> readFaces() override;
 
      const Vertices &vertices() const {return mVertices;}
      const Faces &faces() const {return mFaces;}
      const Edges &edges() const {return mEdges;}
 
      void setVertices( Vertices vertices );
 
      void setFaces( Faces faces );
 
      void setEdges( Edges edges );
 
      size_t verticesCount() const override {return mVertices.size();}
      size_t edgesCount() const override {return mEdges.size();}
      size_t facesCount() const override {return mFaces.size();}
      BBox extent() const override;
      void addVertices( size_t vertexCount, double *coordinates ) override;
      void addFaces( size_t faceCount, size_t driverMaxVerticesPerFace, int *faceSizes, int *vertexIndices ) override;
      void addEdges( size_t edgeCount, int *startVertexIndices, int *endVertexIndices ) override;
 
      bool isEditable() const override {return true;}
 
    private:
      BBox mExtent;
      Vertices mVertices;
      Faces mFaces;
      Edges mEdges;
  };
 
  class MemoryMeshVertexIterator: public MeshVertexIterator
  {
    public:
      MemoryMeshVertexIterator( const MemoryMesh *mesh );
      ~MemoryMeshVertexIterator() override;
 
      size_t next( size_t vertexCount, double *coordinates ) override;
 
      const MemoryMesh *mMemoryMesh;
      size_t mLastVertexIndex = 0;
  };
 
  class MemoryMeshEdgeIterator: public MeshEdgeIterator
  {
    public:
      MemoryMeshEdgeIterator( const MemoryMesh *mesh );
      ~MemoryMeshEdgeIterator() override;
 
      size_t next( size_t edgeCount,
                   int *startVertexIndices,
                   int *endVertexIndices ) override;
 
      const MemoryMesh *mMemoryMesh;
      size_t mLastEdgeIndex = 0;
  };
 
  class MemoryMeshFaceIterator: public MeshFaceIterator
  {
    public:
      MemoryMeshFaceIterator( const MemoryMesh *mesh );
      ~MemoryMeshFaceIterator() override;
 
      size_t next( size_t faceOffsetsBufferLen,
                   int *faceOffsetsBuffer,
                   size_t vertexIndicesBufferLen,
                   int *vertexIndicesBuffer ) override;
 
      const MemoryMesh *mMemoryMesh;
      size_t mLastFaceIndex = 0;
  };
} // namespace MDAL
#endif //MDAL_MEMORY_DATA_MODEL_HPP