LDM/SoLDMMediator.h

Go to the documentation of this file.

/*=======================================================================
 *** 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-2020 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/SoLDMTileManager.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;

SoEXTENDER_Documented class  SoLDMMediator
{
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 ;
  inline 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 ;

  inline bool hasMultiDataError() const;

private:

  void registerWithIds(SoDataSet* ds, std::vector<int> ids, bool sync);

  void unregisterAllIds(SoDataSet* ds, SoLDMMediator* newMediator = NULL);

  void unregisterAll();

  //for user defined LDM component
  bool m_userVisitor;
  SoLDMProximityVisitor*   m_internalVisitor;
  bool m_userTileManager;
  SoLDMMultiIOTileManager* m_internalTileManager;
  SoLDMTileManager* getTileManager() { return m_tileManager; }
  SoLDMTextureManager*  getTextureManager() { return m_textureManager; }
  SoLDMGeometry*    getVVizGeometry() { return m_vvizGeometry; }

  SoLDMTileManager::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;

  inline SoDataSet* getFirstDataSet() const;

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

#if 1             SoDEPRECATED
  void useFixedTileVisitor(bool flag);
#endif /* @DEPRECATED_END */

private:
  SoLDMTileManager      *m_tileManager;
  SoLDMTileVisitor      *m_tileVisitor;
  SoLDMNodeFrontManager *m_nodeFrontManager;

private:
  SoLDMTextureManager   *m_textureManager;
  SoLDMGeometry     *m_vvizGeometry;
  SoDataCompositor      *m_dc;

private:
  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;

SoEXTENDER_Documented public:

  SoEXTENDER_Documented class  LDMManagerAccess {

  public:
    LDMManagerAccess(){};

    void setMediator(SoLDMMediator* mediator)
    { m_mediator = mediator; };

    void setNodeFrontManager( SoLDMNodeFrontManager* );

    inline SoLDMNodeFrontManager* getNodeFrontManager() { return m_mediator->m_nodeFrontManager; }

#if 1             SoDEPRECATED
    void setTileVisitor(SoLDMTileVisitor*, SbBool ownedByUser = TRUE);
SoDEPRECATED
    SoLDMTileVisitor* getTileVisitor();
SoDEPRECATED
    bool isTileVisitorOwnedByUser() const;
SoDEPRECATED
    SoLDMGeometry* getVVizGeometry() { return m_mediator->getVVizGeometry(); }
#endif /* @DEPRECATED_END */

    void setTileManager(SoLDMTileManager* tilemgr, SbBool ownedByUser = TRUE);

    SoLDMTileManager* getTileManager() { return m_mediator->getTileManager(); }

    SoLDMTextureManager*  getTextureManager() { return m_mediator->getTextureManager(); }

    SoLDMResourceManager* getResourceManager(int id = -1);

  private:
    SoLDMMediator* m_mediator;
  };// END LDMManagerAccess definition

private:
  LDMManagerAccess      ldmManagerAccess;
  SoLDMDataAccess&        getDataAccess ( int id = -1 );
  SoLDMDataAccess&        getDataAccess ( SoDataSet* ds );


  LDMResourceParameter* getResourceParameter(int dataEntry);
private:
  // 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 ldmDataAccessList;
  SbThreadMutex* m_semDataAccessList;

  private:
    bool m_isTileVisitorFixedRes;

};

/*****************************************************************************/
SoDataSet*
SoLDMMediator::getFirstDataSet() const
{
  if ( m_volumeDataList.empty() )
    return NULL;

  return m_volumeDataList[0].dsIdPair.first;
}

/*****************************************************************************/
bool
SoLDMMediator::hasMultiDataError() const
{
  return m_multiDataError;
}

inline bool
SoLDMMediator::isAlreadyInFixResMode() const
{
  return m_isTileVisitorFixedRes;
}

inline void
SoLDMMediator::useFixedTileVisitor(bool flag)
{
  m_isTileVisitorFixedRes = flag;
}

#ifdef _MSC_VER
#pragma warning( pop )
#endif

#endif

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/