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-2021 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 /* @DEPRECATED_END */

  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

---

Open Inventor Toolkit reference manual, generated on 15 Mar 2023
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/