tlp::GlQuadTreeLODCalculator Class Reference

#include <GlQuadTreeLODCalculator.h>

Inheritance diagram for tlp::GlQuadTreeLODCalculator:

[legend]

Collaboration diagram for tlp::GlQuadTreeLODCalculator:

[legend]

List of all members.

Public Member Functions

GlQuadTreeLODCalculator ()
~GlQuadTreeLODCalculator ()
void setScene (GlScene &scene)
bool needEntities ()
void setNeedEntities (bool)
void addSimpleEntityBoundingBox (GlSimpleEntity *entity, const BoundingBox &bb)
void addNodeBoundingBox (unsigned int id, const BoundingBox &bb)
void addEdgeBoundingBox (unsigned int id, const BoundingBox &bb)
void compute (const Vector< int, 4 > &globalViewport, const Vector< int, 4 > &currentViewport)
void computeFor3DCamera (LayerLODUnit *layerLODUnit, const Coord &eye, const Matrix< float, 4 > transformMatrix, const Vector< int, 4 > &globalViewport, const Vector< int, 4 > &currentViewport)
void setInputData (GlGraphInputData *newInputData)
virtual GlLODCalculator * clone ()

Protected Member Functions

void update (PropertyInterface *property)
void observableDestroyed (Observable *)
void afterSetNodeValue (PropertyInterface *, const node n)
void afterSetEdgeValue (PropertyInterface *, const edge e)
void afterSetAllNodeValue (PropertyInterface *)
void afterSetAllEdgeValue (PropertyInterface *)
void addNode (Graph *, const node)
void addEdge (Graph *, const edge)
void delNode (Graph *, const node)
void delEdge (Graph *, const edge)
void addLocalProperty (Graph *, const std::string &name)
void delLocalProperty (Graph *, const std::string &name)
void destroy (Graph *)
void destroy (Camera *)
void addLayer (GlScene *, const std::string &, GlLayer *)
void delLayer (GlScene *, const std::string &, GlLayer *)
void modifyLayer (GlScene *, const std::string &, GlLayer *)
void modifyEntity (GlScene *, GlSimpleEntity *)
void removeObservers ()
void addObservers ()
void initCamerasObservers ()
void clearCamerasObservers ()
void setHaveToCompute ()

Protected Attributes

std::vector< QuadTreeNode
< unsigned int > * > nodesQuadTree
std::vector< QuadTreeNode
< unsigned int > * > edgesQuadTree
std::vector< QuadTreeNode
< GlSimpleEntity * > * > entitiesQuadTree
std::vector< std::vector
< SimpleEntityLODUnit > > simpleEntities
bool haveToCompute
BoundingBox nodesGlobalBoundingBox
BoundingBox edgesGlobalBoundingBox
BoundingBox entitiesGlobalBoundingBox
std::vector< Camera * > cameras
std::map< GlLayer *, std::pair
< Camera *, Camera > > layerToCamera
Camera * currentCamera
Graph * currentGraph
PropertyInterface * layoutProperty
PropertyInterface * sizeProperty
PropertyInterface * selectionProperty
int quadTreesVectorPosition
int simpleEntitiesVectorPosition

Detailed Description

Class use to compute bounding boxs of a vector of GlEntity

Constructor & Destructor Documentation

tlp::GlQuadTreeLODCalculator::GlQuadTreeLODCalculator ( )

tlp::GlQuadTreeLODCalculator::~GlQuadTreeLODCalculator ( )

Member Function Documentation

void tlp::GlQuadTreeLODCalculator::addEdge	(	Graph *	,
		const	edge
	)			`[inline, protected]`

void tlp::GlQuadTreeLODCalculator::addEdgeBoundingBox	(	unsigned int	id,
		const BoundingBox &	bb
	)			`[virtual]`

Add a bounding box for an edge

Reimplemented from tlp::GlCPULODCalculator.

void tlp::GlQuadTreeLODCalculator::addLayer	(	GlScene *	,
		const std::string &	,
		GlLayer *
	)			`[inline, protected, virtual]`

This function is call when we add a new layer

Reimplemented from tlp::GlSceneObserver.

void tlp::GlQuadTreeLODCalculator::addLocalProperty	(	Graph *	,
		const std::string &	name
	)			`[protected]`

void tlp::GlQuadTreeLODCalculator::addNode	(	Graph *	,
		const	node
	)			`[inline, protected]`

void tlp::GlQuadTreeLODCalculator::addNodeBoundingBox	(	unsigned int	id,
		const BoundingBox &	bb
	)			`[virtual]`

Add a bounding box for a node

Reimplemented from tlp::GlCPULODCalculator.

void tlp::GlQuadTreeLODCalculator::addObservers ( ) [protected]

void tlp::GlQuadTreeLODCalculator::addSimpleEntityBoundingBox	(	GlSimpleEntity *	entity,
		const BoundingBox &	bb
	)			`[virtual]`

Add a bounding box for a simple entity

Reimplemented from tlp::GlCPULODCalculator.

void tlp::GlQuadTreeLODCalculator::afterSetAllEdgeValue ( PropertyInterface * ) [protected]

void tlp::GlQuadTreeLODCalculator::afterSetAllNodeValue ( PropertyInterface * ) [protected]

void tlp::GlQuadTreeLODCalculator::afterSetEdgeValue	(	PropertyInterface *	,
		const edge	e
	)			`[protected]`

void tlp::GlQuadTreeLODCalculator::afterSetNodeValue	(	PropertyInterface *	,
		const node	n
	)			`[protected]`

void tlp::GlQuadTreeLODCalculator::clearCamerasObservers ( ) [protected]

virtual GlLODCalculator* tlp::GlQuadTreeLODCalculator::clone ( ) [inline, virtual]

Reimplemented from tlp::GlCPULODCalculator.

void tlp::GlQuadTreeLODCalculator::compute	(	const Vector< int, 4 > &	globalViewport,
		const Vector< int, 4 > &	currentViewport
	)			`[virtual]`

Compute all bounding boxes If you want to compute LOD for a simple scene, you just have to call this function with same value on globalViewport and currentViewport But if you want to perform a sub screen part selection you have to call this function with : globalViewport the viewport of the visualisation and currentViewport the viewport of the selection

Parameters:

	globalViewport	is used to compute LOD
	currentViewport	: return -1 for all entities outside this viewport

Reimplemented from tlp::GlCPULODCalculator.

void tlp::GlQuadTreeLODCalculator::computeFor3DCamera	(	LayerLODUnit *	layerLODUnit,
		const Coord &	eye,
		const Matrix< float, 4 >	transformMatrix,
		const Vector< int, 4 > &	globalViewport,
		const Vector< int, 4 > &	currentViewport
	)			`[virtual]`

Reimplemented from tlp::GlCPULODCalculator.

void tlp::GlQuadTreeLODCalculator::delEdge	(	Graph *	,
		const	edge
	)			`[inline, protected]`

void tlp::GlQuadTreeLODCalculator::delLayer	(	GlScene *	,
		const std::string &	,
		GlLayer *
	)			`[inline, protected, virtual]`

This function is call when we remove a layer

Reimplemented from tlp::GlSceneObserver.

void tlp::GlQuadTreeLODCalculator::delLocalProperty	(	Graph *	,
		const std::string &	name
	)			`[protected]`

void tlp::GlQuadTreeLODCalculator::delNode	(	Graph *	,
		const	node
	)			`[inline, protected]`

void tlp::GlQuadTreeLODCalculator::destroy ( Camera * ) [protected, virtual]

This function is call when we delete the camera (call in camera destructor)

Reimplemented from tlp::CameraObserver.

void tlp::GlQuadTreeLODCalculator::destroy ( Graph * ) [protected]

void tlp::GlQuadTreeLODCalculator::initCamerasObservers ( ) [protected]

void tlp::GlQuadTreeLODCalculator::modifyEntity	(	GlScene *	,
		GlSimpleEntity *
	)			`[inline, protected, virtual]`

This function is call when we modify an entity

Reimplemented from tlp::GlSceneObserver.

void tlp::GlQuadTreeLODCalculator::modifyLayer	(	GlScene *	,
		const std::string &	,
		GlLayer *
	)			`[inline, protected, virtual]`

This function is call when we add an entity to the layer

Reimplemented from tlp::GlSceneObserver.

bool tlp::GlQuadTreeLODCalculator::needEntities ( )

void tlp::GlQuadTreeLODCalculator::observableDestroyed ( Observable * ) [inline, protected]

void tlp::GlQuadTreeLODCalculator::removeObservers ( ) [protected]

void tlp::GlQuadTreeLODCalculator::setHaveToCompute ( ) [protected]

void tlp::GlQuadTreeLODCalculator::setInputData ( GlGraphInputData * newInputData )

void tlp::GlQuadTreeLODCalculator::setNeedEntities ( bool )

void tlp::GlQuadTreeLODCalculator::setScene ( GlScene & scene )

void tlp::GlQuadTreeLODCalculator::update ( PropertyInterface * property ) [protected]

Member Data Documentation

std::vector<Camera *> tlp::GlQuadTreeLODCalculator::cameras [protected]

Camera* tlp::GlQuadTreeLODCalculator::currentCamera [protected]

Graph* tlp::GlQuadTreeLODCalculator::currentGraph [protected]

BoundingBox tlp::GlQuadTreeLODCalculator::edgesGlobalBoundingBox [protected]

std::vector<QuadTreeNode<unsigned int> *> tlp::GlQuadTreeLODCalculator::edgesQuadTree [protected]

BoundingBox tlp::GlQuadTreeLODCalculator::entitiesGlobalBoundingBox [protected]

std::vector<QuadTreeNode<GlSimpleEntity *> *> tlp::GlQuadTreeLODCalculator::entitiesQuadTree [protected]

bool tlp::GlQuadTreeLODCalculator::haveToCompute [protected]

std::map<GlLayer*,std::pair<Camera*, Camera> > tlp::GlQuadTreeLODCalculator::layerToCamera [protected]

PropertyInterface* tlp::GlQuadTreeLODCalculator::layoutProperty [protected]

BoundingBox tlp::GlQuadTreeLODCalculator::nodesGlobalBoundingBox [protected]

std::vector<QuadTreeNode<unsigned int> *> tlp::GlQuadTreeLODCalculator::nodesQuadTree [protected]

int tlp::GlQuadTreeLODCalculator::quadTreesVectorPosition [protected]

PropertyInterface* tlp::GlQuadTreeLODCalculator::selectionProperty [protected]

std::vector<std::vector<SimpleEntityLODUnit> > tlp::GlQuadTreeLODCalculator::simpleEntities [protected]

int tlp::GlQuadTreeLODCalculator::simpleEntitiesVectorPosition [protected]

PropertyInterface* tlp::GlQuadTreeLODCalculator::sizeProperty [protected]