SoLDMMediator.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 _SO_MEDIATOR_
#define _SO_MEDIATOR_
 
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif
 
#include <Inventor/STL/vector>
#include <Inventor/SbBox.h>
#include <LDM/SoLDMTileID.h>
#include <LDM/SoLDMResourceManager.h>
#include <LDM/nodes/SoLDMResourceParameters.h>
 
#include <LDM/SoLDMDataAccess.h>
 
#include <LDM/elements/SoDataSetElement.h>
 
 
// LDM
class SoLDMTileVisitor;
class SoLDMProximityVisitor;
class SoLDMMultiIOTileManager;
class SoLDMNodeFrontManager;
class SoLDMTextureManager;
class SoLDMGeometry;
class SoLDMResourceManager;
class SoDataCompositor;
class LDMDefaultSliceAccessor;
class SoGLRenderAction;
class SoDataSet;
class SoState;
class SoLdmParameterNode;
class SoBufferObject;
class SbThreadSemaphore;
class SoDataSetId;
class SoLdmValuationAction;
class SoLDMTileInfo;
class SoLDMTileManager;
class LDMSliceAccessor;
 
 
{
public:
  SoLDMMediator();
 
  virtual ~SoLDMMediator();
 
private:
 
  void registerNode(const SoLDM::DataSetIdPair& dsIdPair, bool sync);
  void unregisterNode(const SoLDM::DataSetIdPair& dsIdPair, SoLDMMediator *newMediator = NULL);
 
  void readTile(int dataSetId, SoLDMTileID tileID, unsigned char* buffer, bool transform) ;
 
  void readTile(const int dataSetId, const SoLDMTileID tileID, SoBufferObject* buffer, const bool transform) ;
 
  size_t readTile(SoLDMTileInfo* tileInfo, const int dataSetId, bool transform);
 
  uint64_t getTileSize(int dataSetId, const SoLDMTileID* tileId = NULL)const ;
  SbVec3i32 getTileDimension()const ;
 
  const SbVec3i32& getDimension()const ;
  const SbBox3f&   getExtent()const ;
  int getOverlapping() const
  {
    return 0;
  }
 
  void renderNotify()const;
 
  const std::vector<int>& getNumData() const ;
 
  SbBool getBbox(SoLDMTileID tileID, SbBox3f& box)const;
  bool getCenter(SoLDMTileID tileID, SbVec3f& center)const;
 
  //stuff I dont know what to do with yet
  SbBool getListChange(){return m_listChange;};
 
  int getDataEntry(unsigned short id)const ;
  int getDataEntry(SoDataSet*)const ;
 
  bool hasMultiDataError() const
  {
    return m_multiDataError;
  }
 
private:
 
  void registerWithIds(SoDataSet* ds, std::vector<int> ids, bool sync);
 
  void unregisterAllIds(SoDataSet* ds, SoLDMMediator* newMediator = NULL);
 
  void unregisterAll();
 
  SoLDMTileManager* getTileManager() { return m_tileManager; }
  SoLDMTextureManager*  getTextureManager() { return m_textureManager; }
  SoLDMGeometry*    getVVizGeometry() { return m_vvizGeometry; }
  SoLDMNodeFrontManager* getNodeFrontManager() { return m_nodeFrontManager; }
 
  LDMSliceAccessor* getSliceAccessor(const SoLDM::DataSetIdPair& p)const;
  void startRenderTraversal(SoLdmValuationAction*, SoDataSet*);
 
  void updateRegions(const SbBox3i32* region, int numRegions);
  /*
   * This function will only be called if in multiple data mode.
   * Called to check if the list of SoDataSet currently stored in the state are also in the list
   * of data set registered to this tile manager (subsequent calls to registerVolumeData).
   * Allows to detect scene graph change ( e.g. a switch node was turned off, the SoDataSet under
   * the switch node is still registered in the tile manager but is not part of the state anymore ).
   * The data compositor present in the state (if any) is also passed to check if it corresponds to the one
   * used by the tile manager (getVolumeData()->getDataCompositor()).
   * If any change occured, tile manager's state must be set accordingly.
   */
  void checkList(SoAction* action, SoDataCompositor* dc);
 
  //Return the biggest buffer id in the m_volumeDataList. When a dataset is no more in the
  //state but is still registered(because of a switch change or a delayed delete in ScaleViz)
  //this number is different from m_volumeDataList.size()-1. So this is this value which must
  //be used for SoLDMTileInfo::extendNumBuffer(int).
  //Ex: bufferIDs(0, 1, 2) -> bufferIDs(0, 2) and m_volumeDataList.size(3) -> m_volumeDataList.size(2)
  int getBiggestBufferEntry() const;
 
  //Do a start/endNumDataNotify without sync in order to be sure that SoLDMMultiIOTileManager::loadingThreadRoutine
  //is running (if there is at least one dataset registered)
  void restartLoadingThread();
 
  // SoDataSet ids vectors
  void updateDataIds() ;
 
  SoDataSet* getVolumeOfId(unsigned short dataSetId)const;
  void getVolumeElements(SoLDM::DataSetIdPairList& dsIdPairList) const;
 
  void getDataSetList(SoLDM::DsVector& dsList) const;
 
  void getDataSetIds(const SoDataSet* ds, std::vector<int>& ids) const;
 
  SoDataSet* getFirstDataSet() const
  {
    if (m_volumeDataList.empty())
      return NULL;
 
    return m_volumeDataList[0].dsIdPair.first;
  }
 
  const SoLDM::DataSetIdPair& getFirstDataSetIdPair() const;
 
  const SoLDM::DataSetIdPairList& getDsIds() const
  {
    return m_dataDsIds;
  }
 
  //After this call, data handled by this mediator will be loaded by LDM's threads
  void addToLDM();
 
  SoDataCompositor* getDataCompositor()const { return m_dc; }
  void setDataCompositor(SoDataCompositor *dc);
 
  struct DataSetInfo
  {
    SoLDM::DataSetIdPair dsIdPair;
    int bufferId;
  };
  typedef std::vector<DataSetInfo> DataSetInfoList;
 
  DataSetInfoList & getVolumeDataList();
 
  bool isAlreadyInFixResMode() const
  {
    return m_isTileVisitorFixedRes;
  }
 
#if 1             SoDEPRECATED
  void useFixedTileVisitor(bool flag)
  {
    m_isTileVisitorFixedRes = flag;
  }
#endif 
  void setTileVisitor( SoLDMTileVisitor* visitor, bool ownedByUser = true );
 
  void setTileManager( SoLDMTileManager* tilemgr, SbBool ownedByUser = TRUE );
 
  SoLDMTileVisitor* getTileVisitor()
  {
    return m_tileVisitor;
  }
 
  bool isTileVisitorOwnedByUser() const { return m_userVisitor; }
 
private:
  SoLDMTextureManager* m_textureManager;
  SoLDMGeometry* m_vvizGeometry;
  SoDataCompositor* m_dc;
  SoLDMTileVisitor* m_tileVisitor;
  SoLDMNodeFrontManager* m_nodeFrontManager;
  SoLDMTileManager* m_tileManager;
 
  //for user defined LDM component
  bool m_userVisitor;
  SoLDMProximityVisitor*   m_internalVisitor;
  bool m_userTileManager;
  SoLDMMultiIOTileManager* m_internalTileManager;
 
  const DataSetInfo& getDataInfo(const SoLDM::DataSetIdPair& dsIdPair) const;
 
  bool isUsedByLDM() { return m_isUsedByLDM; }
  void setUsedByLDM(bool flag) { m_isUsedByLDM = flag; }
  bool m_isUsedByLDM;
 
  std::vector<int> m_dataIds ;
  SoLDM::DataSetIdPairList m_dataDsIds;
 
  std::vector<DataSetInfo> m_volumeDataList;
  bool isInList(const SoLDM::DataSetIdPair& dsIdPair)const;
 
  // Available buffer entries (ie id) for data
  std::vector<int> m_availBufferEntry;
 
  void addToList(const SoLDM::DataSetIdPair& dsIdPair);
  void removeFromList(const SoLDM::DataSetIdPair& dsIdPair);
  void setListChange(bool val){m_listChange = val;};
  bool m_listChange;
 
  void createLDMCore();
  void deleteLDMCore();
 
  void setMinResolutionThreshold();
 
  bool isMultiDataPossible();
 
  bool m_multiDataError;
 
  static int s_debugMediator;
 
private:
  SoLDMDataAccess&        getDataAccess ( int id = -1 );
  SoLDMDataAccess&        getDataAccess ( SoDataSet* ds );
 
  SoLDMResourceManager* getResourceManager(int id);
 
  SoLDMResourceParameters* getResourceParameter( int dataEntry );
  SoLDMResourceParameters* getFirstResourceParameter();
 
private:
 
  bool m_isTileVisitorFixedRes;
 
  // We use a map of LDMDataAccess to be able to
  // support multi thread. One Data Access per thread id
  typedef std::map<SbThreadId_t, SoLDMDataAccess*> t_dataAccessList;
 
  t_dataAccessList m_ldmDataAccessList;
  SbThreadMutex* m_semDataAccessList;
 
};
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
#endif