SoLDMDataAccess.h

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2024 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
#ifndef LDM_DATA_ACCESS_H
#define LDM_DATA_ACCESS_H
 
#include <Inventor/SbLinear.h>
#include <Inventor/SbBox.h>
#include <LDM/SoLDMTileID.h>
 
#include <Inventor/STL/vector>
#include <Inventor/STL/map>
 
#include <Inventor/devices/SoBufferObject.h>
#include <Inventor/devices/SoCpuBufferObject.h>
 
#include <LDM/nodes/SoLDMResourceParameters.h>
 
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif
 
class SoDataSet;
class SoLDMMediator;
class SoPerfCounter;
class SoPerfCounterManager;
class SoCpuBufferObject;
class SbThread;
class SbThreadBarrier;
class SoLDMAlgorithms;
 
 
class  SoLDMDataAccess {
 
public:
 
  SoLDMDataAccess();
 
  virtual ~SoLDMDataAccess();
 
  void setDataSet(SoDataSet* v);
 
  inline SoDataSet* getDataSet();
 
  enum ErrorValue
  {
    CORRECT,
    INCORRECT_RESOLUTION,
    INCORRECT_SUBVOLUME,
    INCORRECT_LINE,
    INCORRECT_POLYLINE,
    INCORRECT_PLANE,
    INCORRECT_POSITION,
    INCORRECT_COORDINATE,
    MEMORY_FULL,
    REQUEST_NOT_COMPLETED,
    REQUEST_NOT_FOUND,
    INCORRECT_BUFFER
  };
 
  enum GetDataMode
  {
    CACHE,
    DIRECT,
    DIRECT_AND_PREFETCH
  };
 
  struct DataInfoBox
  {
    ErrorValue errorFlag;
    int64_t       bufferSize;
    SbVec3i32    bufferDimension;
  };
 
  struct DataInfoTrace
  {
    ErrorValue errorFlag;
    int64_t        bufferSize;
    int        bufferDimension;
  };
 
  struct DataInfoLine
  {
    ErrorValue errorFlag;
    int64_t        bufferSize;
    int        bufferDimension;
    SbVec3i32    lineCoord[2];
  };
  class  DataInfoPolyLine
  {
  public:
 
    DataInfoPolyLine(int numPoint);
    virtual ~DataInfoPolyLine();
 
    DataInfoPolyLine(const DataInfoPolyLine& A);
    void operator=(const DataInfoPolyLine& A);
 
    ErrorValue errorFlag;
 
    int64_t         bufferSize;
 
    int numSegment;
 
    int*  segmentBufferDim;
 
    int*  segmentBufferSize;
 
    SbVec3i32**   segmentCoord;
 
    private:
    private:
 
    DataInfoPolyLine();
    void free();
    void commonConstructor();
    void allocate(int numPoint);
  };
 
  struct DataInfoPlane
  {
    ErrorValue errorFlag;
    int64_t        bufferSize;
    SbVec2i32  bufferDimension;
    int        numPolygonPoints;
    SbVec3i32  polygonCoord[6];
    SbVec3i32  quadCoord[4];
    int        uAxis;
    int        vAxis;
  };
 
  struct DataInfo
  {
    ErrorValue errorFlag;
    SoLDMTileID tileID;
    SbVec3i32 tileDimension;
    SbBox3i32 tilePosition;
    int64_t bufferSize;
    void* tileData;
  };
 
  DataInfoBox getData(int resolution, const SbBox3i32& subVolume0, SoBufferObject* bufferObj = NULL);
 
  DataInfoPlane  getData(int resolution, const SbBox3i32& subVolume0, const SbPlane& plane, 
                        SoBufferObject* bufferObj = NULL);
 
  DataInfoLine getData(int resolution, const SbBox3i32& subVolume0, const SbLine&  line , SoBufferObject* bufferObj = NULL) ;
 
  DataInfoTrace getData( int resolution, const SbBox3i32& subVolume, const SbVec2i32 coord, 
                       SoBufferObject* bufferObj = NULL);
 
  void getData(DataInfoPolyLine& infoPolyline, int resolution, const SbBox3i32& subVolume, int numPoints,
               const SbVec3i32* polyline, SoBufferObject* bufferObj = NULL);
 
  DataInfo getData(int resolution, const SbVec3i32& dataPosition);
 
  void releaseData(SoLDMTileID tileID);
 
  SbBool isTileUniform(int resolution, const SbVec3i32& dataPosition, double& uniformValue);
 
  // asynchronous data access
 
  int requestData(int resolution, const SbBox3i32& box, SoBufferObject* bufferObj);
 
  void getRequestedData(int requestId, DataInfoBox& infoBox);
 
  int requestData(int resolution, const SbBox3i32& subVolume, const SbPlane& plane, SoBufferObject* bufferObj);
 
  void getRequestedData(int requestId, DataInfoPlane& infoPlane);
 
  int requestData(int resolution, const SbBox3i32& subVolume0, const SbLine& line , SoBufferObject* bufferObj);
 
  void getRequestedData(int requestId, DataInfoLine& infoLine);
 
  int requestData(int resolution, const SbBox3i32& subVolume, int numPoints, const SbVec3i32* polyline, SoBufferObject* bufferObj);
 
  void getRequestedData(int requestId, DataInfoPolyLine& infoPolyline);
 
  int requestData(int resolution, const SbBox3i32& subVolume0, const SbVec2i32&  coord, SoBufferObject* bufferObj);
 
  void getRequestedData(int requestId, DataInfoTrace& infoTrace);
 
  virtual void endRequest(int requestId);
 
  SbVec3f voxelToXYZ(const SbVec3i32 &dataPosition);
 
  SbBox3f voxelToXYZ( const SbBox3i32& boxIJK );
 
  SbVec3i32 XYZToVoxel(const SbVec3f &dataPosition);
 
  SbBox3i32 XYZToVoxel( const SbBox3f& boxXYZ );
 
  bool setGetDataMode (const GetDataMode getDataMode);
 
  GetDataMode getGetDataMode();
 
 
#if 1             SoDEPRECATED
  DataInfoBox getData(int resolution, const SbBox3i32& subVolume, void* buffer);
SoDEPRECATED
  DataInfoPlane getData(int resolution, const SbBox3i32& subVolume, const SbPlane& plane,
                        void* buffer);
SoDEPRECATED
  DataInfoLine getData(int resolution, const SbBox3i32& subVolume, const SbLine&  line , void* buffer);
SoDEPRECATED
  DataInfoTrace getData(int resolution, const SbBox3i32& subVolume, const SbVec2i32 coord,
                       void* buffer );
SoDEPRECATED
  void getData(DataInfoPolyLine& infoPolyline, int resolution, const SbBox3i32& subVolume, int numPoints,
               const SbVec3i32* polyline, void* buffer);
SoDEPRECATED
  int requestData(int resolution, const SbBox3i32& subVolume, void* buffer);
SoDEPRECATED
  int requestData(int resolution, const SbBox3i32& subVolume, const SbPlane& plane, void* buffer);
SoDEPRECATED
  int requestData(int resolution, const SbBox3i32& subVolume, const SbLine& line, void* buffer);
SoDEPRECATED
  int requestData(int resolution, const SbBox3i32& subVolume, int numPoints, const SbVec3i32* polyline, void* buffer);
SoDEPRECATED
  int requestData(int resolution, const SbBox3i32& subVolume, const SbVec2i32& coord, void* buffer);
 
#endif 
private:
 
  void initPerfCounters();
  void resetPerfCounters();
  bool intersectWith(const SbBox3i32 &, const SbBox3i32 &, SbBox3i32 &);
  int  intersectWith(const SbBox3i32 &, const SbPlane &, int, SbVec3i32 [], SbVec3i32 []) const;
  bool intersectWith(const SbBox3i32 &, const SbLine &, SbVec3i32 []) const;
  int  getZaxis(const SbVec3f &) const;
  void copyData(unsigned short dataSetId, SoLDMTileID tile, SoBufferObject* tileBufferObj, int tileIndex);
  void copyData(unsigned short dataSetId, SoLDMTileID tile, SoBufferObject* tileBufferObj, int tileIndex, int requestId, bool canRelease=true);
  void requestNotCompleted(int requestId);
  std::vector<SoLDMTileID> getRequestedTiles(int requestId);
  SoDataSet* getRequestingDataSet(int requestId);
  bool isTileToPrefecth(const SoLDMTileID &tileId);
  void removeTileFromPrefetch(const SoLDMTileID &tileId);
  SbThreadBarrier* getDataAccessBarrier();
  SbThreadBarrier* getReaderThreadBarrier();
  
  //info needed when copyData is called
  enum CopyWhat{
    COPY_BOX,
    COPY_PLANE,
    COPY_LINE,
    COPY_SINGLE,
    COPY_TRACE
  };
 
  CopyWhat getTypeOfCopy () { return m_copyInfo.copyWhat;};
 
private:
  int  clipSegment(const SbVec3i32 &, const SbVec3i32 &, SbVec3i32 *, int, const SbVec3i32 &, const SbVec3i32 &) const;
 
  //check if box is flat and readjust
  void      checkBox(int& _max, int& _min, int volBox);
  SbBox3i32 getBox(SbVec3i32 p1, SbVec3i32 p2, SbBox3i32 volBox);
 
  // TODO: this class should not be defined in a public header
  // and should be cleanup
  struct CopyInfo {
  public:
    CopyInfo()
    { reset(); }
 
    // reset all members to a well define default value
    void reset()
    {
      destBufferObj = NULL;
      userCpuObj = NULL;
      vmin = SbVec3i32(0,0,0);
      vmax = SbVec3i32(0,0,0);
      tileDim = -1;
      dataSize = -1;
      subVolume.makeEmpty();
      resolution = -1;
      copyWhat = COPY_SINGLE;
      qmin = SbVec2i32(0,0);
      qmax = SbVec2i32(0,0);
      normal = SbVec3f(0,0,0);
      distance = -1;
      Zaxis = -1;
      voxelsToCopy = NULL;
 
      // asynchronous access
      tiles.clear();
      tilesFromDisk.clear();
      tilesToPrefetch.clear();
      tilesInfos.clear();
      tilesIndex.clear();
      ldmDataAccess = NULL;
      dataSet = NULL;
      loadPolicy = SoLDMResourceParameters::NEVER;
      requestSize = -1;
      requestId = -1;
      shouldCallback = false;
      dataInfoPolyline = NULL;
      dataInfoLine = NULL;
      dataInfoPlane = NULL;
      dataInfoBox = NULL;
      dataInfoTrace = NULL;
    }
 
  public:
    SoRef<SoBufferObject> destBufferObj;
    SoRef<SoCpuBufferObject> userCpuObj;
    SbVec3i32 vmin;
    SbVec3i32 vmax;
    int tileDim;
    int dataSize;
    SbBox3i32 subVolume;
    int resolution;
    CopyWhat copyWhat;
    SbVec2i32 qmin;
    SbVec2i32 qmax;
    SbVec3f normal;
    float distance;
    SbPlane plane;
    int Zaxis;
    SbVec2i32 bufDim;
    std::vector< std::vector<SbVec2i32> >* voxelsToCopy;
    // asynchronous access
    std::vector<SoLDMTileID> tiles;
    std::vector<SoLDMTileID> tilesFromDisk;
    std::vector<SoLDMTileID> tilesToPrefetch;
    std::map<int64_t, SbVec3i32> tilesInfos;
    std::map<int64_t, int> tilesIndex;
    SoLDMDataAccess* ldmDataAccess;
    SoDataSet* dataSet;
    SoLDMResourceParameters::LoadPolicy loadPolicy;
    int64_t requestSize;
    int requestId;
    bool shouldCallback;
    DataInfoPolyLine* dataInfoPolyline;
    DataInfoLine* dataInfoLine;
    DataInfoPlane* dataInfoPlane;
    DataInfoBox* dataInfoBox;
    DataInfoTrace* dataInfoTrace;
  } m_copyInfo;
 
 
private:
  enum threadType
  { NONE = 0,
    PLANE,
    BOX,
    TRACES,
    LINE,
    POLYLINE
  };
  
  SoLDMDataAccess& operator=(const SoLDMDataAccess& ldmDa);
  SoLDMDataAccess(const SoLDMDataAccess& );
 
  SoDataSet      *m_dataSet;
  SoLDMMediator  *m_mediator;
 
  std::map<int, CopyInfo> m_requests;
 
  //bool getRequestInfo(int resolution, const SbBox3i32& subVolume0, void *buffer, DataInfoBox& info, CopyInfo& copyInfo);
  bool getRequestInfo(int resolution, const SbBox3i32& subVolume0, SoBufferObject *bufferObj, DataInfoBox& info, CopyInfo& copyInfo);
 
  bool getRequestInfo(int resolution, const SbBox3i32& subVolume0, const SbPlane& plane, SoBufferObject *bufferObj,
                      SoLDMDataAccess::DataInfoPlane& info, SoLDMDataAccess::CopyInfo& copyInfo);
  
  bool getRequestInfo(int resolution, const SbBox3i32& subVolume0, const SbLine& line, SoBufferObject *bufferObj,
                      SoLDMDataAccess::DataInfoLine& info, SoLDMDataAccess::CopyInfo& copyInfo);
  
  bool getRequestInfo(int resolution, const SbBox3i32& subVolume0, const SbVec2i32 coord, SoBufferObject *bufferObj,
                      SoLDMDataAccess::DataInfoTrace& info, SoLDMDataAccess::CopyInfo& copyInfo);
 
  //void copyData(unsigned short dataSetId, SoLDMTileID tile, void* bufferTile, int tileIndex, CopyInfo& copyInfo);
  void copyData(unsigned short , SoLDMTileID tile, SoBufferObject* tileBufferObj, int tileIndex, SoLDMDataAccess::CopyInfo& copyInfo);
 
  static void *readTraceFromDiskThreadRoutine(void* userData);
  static void *readSliceFromDiskThreadRoutine(void* userData);
  static void *readTilesFromDiskThreadRoutine(void* userData);
  void readSliceInTile(SoLDMDataAccess* dataAccess, int fileID, SbBox3i32& tilePos, int& sliceNumber, SoBufferObject* destBuffer );
  void buildPlane(SoLDMDataAccess* dataAccess, int firstAxis, int secondAxis, int sliceNumber);
  bool createThreadReadDisk(SoLDMDataAccess::threadType threadType);
  void updateTilesLists(SoLDMDataAccess::CopyInfo& copyInfo);
  void checkGetDataMode (const SoLDMDataAccess::CopyWhat copyWhat);
 
  enum RequestState {
    NOT_FOUND,
    OK
  };
 
  RequestState queryRequestState(int requestId);
 
  int m_nextRequestId;
  int getNextRequestId();
 
  SoPerfCounterManager* m_perf;
 
  // Perf counter used for data copy timing
  SoPerfCounter* m_time_copy_data_trace;
  SoPerfCounter* m_time_copy_data_vol;
  SoPerfCounter* m_time_copy_data_plane;
 
  // Perf counter used for tile select timing
  SoPerfCounter* m_time_tile_select_trace;
  SoPerfCounter* m_time_tile_select_vol;
  SoPerfCounter* m_time_tile_select_plane;
 
  SoLDMAlgorithms* m_algorithms;
 
  GetDataMode m_getDataMode;
 
  SbThreadBarrier *m_readerBarrier;
  SbThreadBarrier *m_diskReadThreadBarrier;
  SbThread *m_diskReadThread;
  bool m_threadMustStop;
  threadType m_threadType;
 
  static void checkBuffer(SoBufferObject* buffer);
 
private:
     CopyInfo& getCopyInfo();
     bool threadMustStop();
 
};// END SoLDMDataAccess definition
 
 
inline SoDataSet*
SoLDMDataAccess::getDataSet()
{
  return m_dataSet; 
}
 
inline void
SoLDMDataAccess::endRequest(int)
{
  SoDebugError::post("SoLDMDataAccess::endRequest", "An asynchronous access has been made using first class SoLDMDataAccess. Please implement your own, overloading endRequest method.");
}
 
inline SoLDMDataAccess::GetDataMode
SoLDMDataAccess::getGetDataMode()
{
  return m_getDataMode;
}
 
inline SoLDMDataAccess::CopyInfo&
SoLDMDataAccess::getCopyInfo()
{
  return m_copyInfo;
}
 
inline bool
SoLDMDataAccess::threadMustStop()
{
  return m_threadMustStop;
}
 
inline SbThreadBarrier* 
SoLDMDataAccess::getDataAccessBarrier()
{
  return m_readerBarrier;
}
 
inline SbThreadBarrier* 
SoLDMDataAccess::getReaderThreadBarrier()
{
 return m_diskReadThreadBarrier;
}
 
/***************************************************************************/
inline SoLDMDataAccess&
SoLDMDataAccess::operator=(const SoLDMDataAccess& )
{
  assert(0);
  return *this;
}
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
#endif /* LDM_DATA_ACCESS_H */