com.openinventor.ldm

Class SoLDMTileManager

java.lang.Object

com.openinventor.inventor.Inventor

com.openinventor.ldm.SoLDMLargeDataManagement

com.openinventor.ldm.SoLDMTileManager

public class SoLDMTileManager
extends SoLDMLargeDataManagement

LDM Tile Manager. This class is only needed for advanced users who intend to extend or replace internal LDM algorithms.

<font color="#0000FF">NOTE:</font> This class does not exist in Open Inventor 10.0 and later.

The SoLDMTileManager is responsible for managing the data in main memory, loading the most important tiles, unloading the less important ones, and delivering them (getTile) to create textures for rendering.

The amount of memory, dedicated to storing the data in main memory, is up to the application and stored in the SoLDMResourceManager. The SoLDMTileManager works under constraint of the SoLDMResourceManager. One can assign a weight to a tile and ask the SoLDMTileManager for the existence of the tile in main memory by calling checkResidencyAndUpdateWeight. Notice: The tile manager should keep track of weights passed through this function to remember priorities. Indeed, even though, weights between tile manager and node front manager are consistent (same weight in between 0 and 1), they are out of synchronisation: if the tile manager declares the tile as not loaded, then the tile's weight will be declared as null to the node front manager (checkResidencyAndUpdateWeight returns false). So the tile manager must know the importance of the tile to know when to load it next, when the balance is reached, and not entirely rely on SoLDMNodeFrontManager.getWeight method.

The tile manager should register the SoDataSet node passed to the registerVolumeData function to access different information needed to page data from disk:

• Access to the reader (dataSet->getReader()) when a tile needs to be loaded
• Access to information about fixed resolution mode if supporting this feature, in this case tiles of non null weight must be loaded synchronously.(access to m_fixedResCB to be called, isFixedResolutionMode function).
• Access to the SoDataCompositor (volData->getDataCompositor()) if in composition mode when handling several SoDataSet.
• Access to the dataSetId when handling several SoDataSet to know what piece of data to return when getTile is called.
• Access to the resources of a given data set when handling several SoDataSet (note there is one resource manager associated to each data set).

As described above, multiple SoDataSet can be inserted in a scene graph and combined together to do render or data compositing (see SoDataSet). In this case, only one SoLDMTileManager handles them all and the registerVolumeData function is called for each data set. In the case of a render compositing, each time a tile needs to be stored in memory, the tile manager needs to load the piece of data corresponding to the tile for each data set registered so that when a tile is declared in memory, the associated data resides for each data set (at any time, the amount of data loaded for each data set must be synchronized). In the case of a data compositing (volData->getDataCompositor() is not NULL) then when a tile is loaded, it must be loaded for each data set, each piece of data must be combined together by the data compositor and the final composed data must be stored and managed by the tile manager.

See also:

SoLDMResourceManager, SoLDMNodeFrontManager, SoDataSet, SoVolumeRendering, LDMDefaultSliceAccessor

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SoLDMTileManager.LDMSliceAccessor Allows accessing a 2D buffer for slice and volumeSkin rendering.

Nested classes/interfaces inherited from class com.openinventor.inventor.Inventor

Inventor.ConstructorCommand

Field Summary

Fields inherited from class com.openinventor.inventor.Inventor

VERBOSE_LEVEL, ZeroHandle

Method Summary

Modifier and Type	Method and Description
boolean	checkResidencyAndUpdateWeight(SoLDMTileID tileID, float weight) Returns whether the input tile resides in memory and update its weight.
void	endNumDataNotify(boolean isAdded, boolean sync) Calls endNumDataNotify(isAdded, sync, (boolean)false).
void	endNumDataNotify(boolean isAdded, boolean sync, boolean shouldInit) Indicates that LDM has finish to modify/upload new data data.
void	endTransaction() Notify a transaction has ended.
void	flushTilesOfRes(int resolution) Flush tiles of a given resolution from memory pool.
int	getMemoryUsed() This function is only used if in multiple data mode.
double[]	getMinMax(SoLDMTileID tile) Gets the minimum and maximum values in a tile of data.
SoBufferObject	getTile(SoLDMTileID tileID, short dataSetId) Gets the data buffer associated with a tile for a given data set.
int	getTileData(java.util.Collection<SoLDMTileID> tileIDs, short volumeDataId, SoLDMDataAccess pDataAccess) This function must ensure that all the data associated with the input set of tiles is loaded in main memory when returning.
SbVec3i32	getTileDimension(SoLDMTileID tileID) Get Tile dimension.
SoBufferObject	getTileExt(SoLDMTileID tileID, short dataSetId) This function must return the data associated with the given tileID and dataSetId but it must be stored as a stack of slices along the X Inventor axis.
void	init(SoLDMTileID tilesToLoad) Function of initialization.
boolean	isDataInMemory(SoLDMTileID tileID) Indicates whether the data attached to a tile is in main memory.
boolean	isInMemory(SoLDMTileID tileID) Indicates whether a tile is in main memory.
void	lockTile(SoLDMTileID tileId) Set the LOCKED state to true for the given SoLDMTileID.
void	lockTiles() Set the LOCKED state to true for all tile loaded in memory.
void	prioritizeTiles(SoLDMTileID maxTileId) Allows to let the user know what tiles are prioritary and should not be reset in the resetWeight functions.
void	releaseTileData(SoLDMTileID tileID) Calls releaseTileData(tileID, (short)-1).
void	releaseTileData(SoLDMTileID tileID, short dataSetId) Releases previously requested data associated with a given tileID from memory.
boolean	requestRefetch(SoLDMTileID tileID, double weight) Launch an asynchronous request for the data attached to the specified tile.
void	resetWeights() Reset weights to init the topology before evaluating it.
void	resourceChangeNotify() Notification of a memory resource change.
void	setAllowLoading(boolean allowLoad) This function is called when using the NO_USER_INTERACTION mode.
void	shouldInit() Indicates that the manager should be initialized.
void	startNumDataNotify() Calls startNumDataNotify((int)-1, (int)-1).
void	startNumDataNotify(int id) Calls startNumDataNotify(id, (int)-1).
void	startNumDataNotify(int id, int entry) Indicates that LDM starts to modify/upload new data data.
void	startTransaction() Functions to keep memory state stable when querying state.
void	unLockTile(SoLDMTileID tileId) Calls unLockTile(tileId, (boolean)false).
void	unLockTile(SoLDMTileID tileId, boolean forceUnload) Set the LOCKED state to false for the given SoLDMTileID.
void	unLockTiles() Set the LOCKED state to false for all tiles loaded in memory.
void	updateRegions(SbBox3i32[] region, int numRegions) Update a region of data in memory.

Methods inherited from class com.openinventor.ldm.SoLDMLargeDataManagement

reset

Methods inherited from class com.openinventor.inventor.Inventor

dispose, getAddress, getNativeResourceHandle, startInternalThreads, stopInternalThreads

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

startNumDataNotify

public void startNumDataNotify(int id)

Calls startNumDataNotify(id, (int)-1).

releaseTileData

public void releaseTileData(SoLDMTileID tileID)

Calls releaseTileData(tileID, (short)-1).

startNumDataNotify

public void startNumDataNotify()

Calls startNumDataNotify((int)-1, (int)-1).

endNumDataNotify

public void endNumDataNotify(boolean isAdded,
                             boolean sync)

Calls endNumDataNotify(isAdded, sync, (boolean)false).

unLockTile

public void unLockTile(SoLDMTileID tileId)

Calls unLockTile(tileId, (boolean)false).

isDataInMemory

public boolean isDataInMemory(SoLDMTileID tileID)

Indicates whether the data attached to a tile is in main memory. Called when the node front manager evaluates the texture front.

This allows to manage data that implements SoBufferAsyncInterface. If the specified tile does not implement SoBufferAsyncInterface then this method always returns true. So effectively it always returns true for non-LDM volumes.

getTile

public SoBufferObject getTile(SoLDMTileID tileID,
                              short dataSetId)

Gets the data buffer associated with a tile for a given data set. LDM expects the data to be stored as a stack of slices along the Z Inventor axis. Called after texture front evaluation. Only called on tiles that the tile manager declared as resident in memory. The input tileID has been called previously by the isInMemory function and the answer was true.

isInMemory

public boolean isInMemory(SoLDMTileID tileID)

Indicates whether a tile is in main memory. Called when the node front manager evaluates the texture front.

resetWeights

public void resetWeights()

Reset weights to init the topology before evaluating it. This function is called before a topology evaluation starting with checkResidencyAndUpdateWeight(0, weight).

getTileExt

public SoBufferObject getTileExt(SoLDMTileID tileID,
                                 short dataSetId)

This function must return the data associated with the given tileID and dataSetId but it must be stored as a stack of slices along the X Inventor axis. Only called if the useExtendedData flag from SoDataSet is true. Allows equalizing performance of axis aligned slices roaming through a data set.

requestRefetch

public boolean requestRefetch(SoLDMTileID tileID,
                              double weight)

Launch an asynchronous request for the data attached to the specified tile. This allows to manage data that implements SoBufferAsyncInterface.

checkResidencyAndUpdateWeight

public boolean checkResidencyAndUpdateWeight(SoLDMTileID tileID,
                                             float weight)

Returns whether the input tile resides in memory and update its weight. The input weight is an indication of how LDM prioritize data for the current scene state. Tiles of higher weight should arrive in memory first. Note that the root tile must always resides in memory.

endNumDataNotify

public void endNumDataNotify(boolean isAdded,
                             boolean sync,
                             boolean shouldInit)

Indicates that LDM has finish to modify/upload new data data.

startNumDataNotify

public void startNumDataNotify(int id,
                               int entry)

Indicates that LDM starts to modify/upload new data data.

init

public void init(SoLDMTileID tilesToLoad)

Function of initialization. This function is called only once after the SoLDMNodeFrontManager initialization (so the tile manager can query the number of data tiles to manage by calling getNodeFrontManager()->getNumFileIDs()). The input parameter indicates which tiles should be in memory after initialization. All tileIds between 0 and up to tilesToLoad must be in memory.

endTransaction

public void endTransaction()

Notify a transaction has ended.

startTransaction

public void startTransaction()

Functions to keep memory state stable when querying state. Indicates a memory transaction is starting. Memory state should not change until endTransaction is called. A transaction is defined as follow: startTransaction() indicates the following set of functions will/might be called to analyze how texture front should evolve and what set of tiles to use to render a particular geometry. Note that the data front managed by the tile manager should evolve based on the weights passed by checkResidencyAndUpdateWeight. For a given transaction, functions will be called in the following order: startTransaction () { prioritizeTiles (for topology evaluation). Only called once for all geometry. getMinMax (for topology evaluation). Only called once for all geometry and if ignoring the fully transparent tiles. setAllowLoading if NO_USER_INTERACTION mode is On. Only called once for all geometry. resetWeights (for topology evaluation). Only called once for all geometry. checkResidencyAndUpdateWeight (for octree evaluation). Only called once for all geometry. isInMemory. Always called per geometry to calculate the texture front. Allows a tile manager user to know what tiles should be locked during a given transaction until getTile is called. getTile or getTileExt. Called per geometry if there is a texture front change or if more texture can be loaded. } endTransaction()

getTileDimension

public SbVec3i32 getTileDimension(SoLDMTileID tileID)

Get Tile dimension. For the default topology (octree) this function should always return the same size.

updateRegions

public void updateRegions(SbBox3i32[] region,
                          int numRegions)

Update a region of data in memory. All the tiles intersecting the regions must be refetched. Called if the application uses the SoDataSet.updateRegion function.

lockTiles

public void lockTiles()

Set the LOCKED state to true for all tile loaded in memory.

prioritizeTiles

public void prioritizeTiles(SoLDMTileID maxTileId)

Allows to let the user know what tiles are prioritary and should not be reset in the resetWeight functions. All tileIds between 0 and up to maxTileId are prioritary. This function is called right before the resetWeight function.

unLockTiles

public void unLockTiles()

Set the LOCKED state to false for all tiles loaded in memory.

flushTilesOfRes

public void flushTilesOfRes(int resolution)

Flush tiles of a given resolution from memory pool. Called only if the fixedResolution LDM mode is ON or if the maximum resolution threshold changes (See LDMResourceParameter).

shouldInit

public void shouldInit()

Indicates that the manager should be initialized.

getMemoryUsed

public int getMemoryUsed()

This function is only used if in multiple data mode. There was a scene graph change in multiple data mode and only one tile manager must remain for all data sets involved. LDM will keep the one that has loaded the more data.

lockTile

public void lockTile(SoLDMTileID tileId)

Set the LOCKED state to true for the given SoLDMTileID.

getTileData

public int getTileData(java.util.Collection<SoLDMTileID> tileIDs,
                       short volumeDataId,
                       SoLDMDataAccess pDataAccess)

This function must ensure that all the data associated with the input set of tiles is loaded in main memory when returning. The data associated to a given tileID must be locked in memory until releaseTileData is called. Called when using the data access functions (getData) from the SoLDMDataAccess.

getMinMax

public double[] getMinMax(SoLDMTileID tile)

Gets the minimum and maximum values in a tile of data.
The returned value indicates whether it has been calculated yet or in other words, if the tile was ever loaded. Only called if ignoring fully transparent tiles (see SoVolumeRendering).

releaseTileData

public void releaseTileData(SoLDMTileID tileID,
                            short dataSetId)

Releases previously requested data associated with a given tileID from memory. If supported, dataSetId allows you to specify which data set should be released. -1 means all data sets in the MultiDataVolumeGroup.

unLockTile

public void unLockTile(SoLDMTileID tileId,
                       boolean forceUnload)

Set the LOCKED state to false for the given SoLDMTileID.

setAllowLoading

public void setAllowLoading(boolean allowLoad)

This function is called when using the NO_USER_INTERACTION mode. This mode should essentially allow loading only when the user does not interact with the scene.

resourceChangeNotify

public void resourceChangeNotify()

Notification of a memory resource change. If the application changes the main memory resource using the SoLDMResourceManager, resourceChangeNotify is called to notify the SoLDMTileManager that more tiles can be loaded or some must be unloaded.