Classes
class	AbstractRenderer

class	AbstractViewer

class	AbstractViewerPrivate

class	Action

class	ActionAdd

class	ActionBuilder

class	ActionBuilderT

class	ActionClear

class	ActionContext

class	ActionContextContainer

class	ActionDispatcher

class	ActionDispatcherPrivate

class	ActionFactory

class	ActionFactoryEntry

class	ActionFactoryPrivate

class	ActionGet

class	ActionHistory

class	ActionInfo
	Information class about an action. More...

class	ActionInfoPrivate

class	ActionOffset

class	ActionParameter
	Parameter for an action. More...

class	ActionParameter< std::string >
	Template specialization for string parameter. More...

class	ActionParameterBase

class	ActionProgress

class	ActionRemove

class	ActionRotateView

class	ActionScaleView

class	ActionSet

class	ActionSetAt

class	ActionSetRange

class	ActionToggle

class	ActionTranslateView

class	Application

class	ApplicationPrivate

class	ArrayMathEngine

class	ArrayMathEnginePrivate

class	ArrayMathFunction
	Functions for databasing the function calls that make up the program. More...

class	ArrayMathFunctionCatalog

class	ArrayMathInterpreter

class	ArrayMathProgram

class	ArrayMathProgramCode

class	ArrayMathProgramPrivate

class	ArrayMathProgramSource

class	ArrayMathProgramSourcePrivate

class	ArrayMathProgramVariable

class	ArrayMathProgramVariablePrivate

class	AtomicCounter

class	BooleanStateGroup

class	BooleanStateGroupPrivate

class	BrickEntry

class	BrickInfo

struct	BrickInfoHash

class	BufferObject

struct	CappingTableType

class	Color
	This class defines an rgb color. More...

class	ColorMap

class	ColorMapPrivate

class	ConnectionHandler
	A simple class for managing connections. More...

class	ConnectionHandlerConnection

class	ConnectionHandlerPrivate

class	DataBlock

class	DataBlockManager

class	DataBlockManagerPrivate

class	DataSlice

class	DataVolume

class	DataVolumeBrick

class	DataVolumeBrickPrivate

class	DataVolumePrivate

class	DataVolumeSlice

class	DefaultEventHandlerContext

class	DefaultEventHandlerContextPrivate

class	DummyRenderer

class	ElementArrayBuffer

class	Event

class	EventHandler

class	EventHandlerContext

class	EventSync
	Auxilary class needed for doing synchronization. More...

class	EventT

class	Exception
	Hence it is recommended to use the macros for throwing the exceptions. More...

class	FileUtil

class	FramebufferObject

class	FreeTypeBitmapGlyph

class	FreeTypeFace

class	FreeTypeGlyph

class	FreeTypeLibrary

class	FreeTypeLibraryFactory

class	GenerationNumber

class	GLSLFragmentShader

class	GLSLProgram

class	GLSLShader

class	GLSLVertexShader

class	GridTransform

class	Histogram

class	IndexVector

class	Interface

class	InterfaceActionContext

class	InterfacePrivate

class	IntrusiveBase

class	InvalidArgument

class	Isosurface

class	IsosurfaceExporter

class	IsosurfacePrivate

class	ITKDataBlock

class	ITKDataBlockPrivate

class	ITKImage2DData

class	ITKImage2DDataT

class	ITKImageData

class	ITKImageDataT

class	LargeVolume

class	LargeVolumeBrickLevel

class	LargeVolumeBrickSlice

class	LargeVolumeBrickSlicePrivate

class	LargeVolumeCache

class	LargeVolumeCachePrivate

class	LargeVolumeConverter

class	LargeVolumeConverterPrivate

class	LargeVolumePrivate

class	LargeVolumeSchema

class	LargeVolumeSchemaPrivate

class	LargeVolumeSlice

class	LargeVolumeSlicePrivate

class	LengthError

class	Lockable

class	LogHistory

class	LogicError

class	LogStreamer

class	LogStreamerPrivate

struct	MarchingCubesTableType

class	MaskDataBlock

class	MaskDataBlockEntry

class	MaskDataBlockManager

class	MaskDataBlockManagerInternal

class	MaskDataSlice

class	MaskVolume

class	MaskVolumeSlice

class	MaskVolumeSlicePrivate

class	Matrix

class	MatrixF

class	Measurement

class	MouseHistory

class	Notifier

class	NotImplementedError

class	NrrdData

class	NrrdDataBlock

class	NrrdDataBlockPrivate

class	NrrdDataPrivate

class	OpenGLException

class	OutOfRange

class	OverflowError

class	Parallel

class	ParallelPrivate

class	Parser

class	ParserFunction

class	ParserFunctionCatalog

class	ParserFunctionCatalogPrivate

class	ParserFunctionPrivate

class	ParserNode

class	ParserNodePrivate

class	ParserPrivate

class	ParserProgram

class	ParserProgramPrivate

class	ParserScriptFunction

class	ParserScriptFunctionPrivate

class	ParserScriptVariable

class	ParserScriptVariablePrivate

class	ParserTree

class	ParserTreePrivate

class	ParserVariable

class	ParserVariablePrivate

class	Path

class	PickPoint

class	PixelBufferObject

class	PixelPackBuffer

class	PixelUnpackBuffer

class	Plane

class	Point

class	PointF

class	PythonActionContext

class	PythonInterpreter

class	PythonInterpreterPrivate

class	Quaternion

class	RangeError

class	RecursiveLockable

class	Renderbuffer

class	RenderContext

class	RenderContextBinding

class	RendererBase

class	RendererBasePrivate

class	RenderResources

class	RenderResourcesContext

class	RenderResourcesPrivate

class	RolloverLogFile

class	RolloverLogFilePrivate

class	Runnable

class	RunTimeError

class	ScopedCounter

class	ShaderBase

class	ShaderBasePrivate

class	SharedLockable

class	SinglePath

class	Singleton
	NOTE: This singleton model requires that the project is linked statically. More...

class	StackBasedVector

class	StackVector

class	StateBase

class	StateBasePrivate

class	StateEngine

class	StateEnginePrivate

class	StateHandler

class	StateHandlerPrivate

class	StateIO

class	StateIOPrivate

class	StateLabeledMultiOption

class	StateLabeledMultiOptionPrivate

class	StateLabeledOption

class	StateLabeledOptionPrivate

class	StateName

class	StateNamePrivate

class	StateOption

class	StateRangedValue

class	StateRangedValueBase
	This pure virtual class defines an extra interface that StateValue provides. More...

class	StateSet

class	StateSetBase

class	StateValue

class	StateVector

class	StateVectorBase

class	StateView2D

class	StateView3D

class	StateViewBase

class	StdDataBlock

class	TextRenderer

class	Texture

class	Texture1D

class	Texture2D

class	Texture3D

class	Timer

class	TimerPrivate

class	TransferFunction

class	TransferFunctionControlPoint

class	TransferFunctionFeature

class	TransferFunctionFeaturePrivate

class	TransferFunctionPrivate

class	Transform

class	TransformF

union	ullong_float_type

class	UnderflowError

class	UnitCube

class	Variant

class	VariantBase

class	VariantT

class	Vector

class	VectorF

class	VertexAttribArrayBuffer

class	VertexBufferBatch

class	VertexBufferObject

class	View2D

class	View3D

class	VolumeRendererBase

class	VolumeRendererBasePrivate

class	VolumeRendererOcclusion

class	VolumeRendererOcclusionPrivate

class	VolumeRendererSimple

class	VolumeRendererSimplePrivate

class	VolumeRenderingParam

class	VolumeShaderOcclusion

class	VolumeShaderSimple

class	VolumeSlice
	A helper class for accessing data in a slice of a volume. More...

class	VolumeSlicePrivate

Typedefs
typedef boost::shared_ptr< Action >	ActionHandle

typedef boost::weak_ptr< Action >	ActionWeakHandle

typedef std::vector< ActionHandle >	ActionHandleList

typedef boost::shared_ptr< ActionContext >	ActionContextHandle

typedef boost::shared_ptr< ActionDispatcherPrivate >	ActionDispatcherPrivateHandle

typedef boost::shared_ptr< ActionBuilder >	ActionBuilderHandle

typedef boost::shared_ptr< ActionFactoryPrivate >	ActionFactoryPrivateHandle

typedef boost::shared_ptr< ActionInfo >	ActionInfoHandle

typedef boost::shared_ptr< ActionInfoPrivate >	ActionInfoPrivateHandle

typedef boost::shared_ptr< ActionProgress >	ActionProgressHandle
	NOTE: The intrusive pointer will allow a handle to be generate inside the class.

typedef Variant	ActionResult

typedef boost::shared_ptr< ActionResult >	ActionResultHandle

typedef boost::shared_ptr< ApplicationPrivate >	ApplicationPrivateHandle

typedef boost::shared_ptr< DataBlock >	DataBlockHandle

typedef boost::weak_ptr< DataBlock >	DataBlockWeakHandle

typedef boost::shared_ptr< DataBlockManagerPrivate >	DataBlockManagerPrivateHandle

typedef boost::shared_ptr< DataSlice >	DataSliceHandle

typedef boost::weak_ptr< DataSlice >	DataSliceWeakHandle

typedef boost::shared_ptr< ITKDataBlock >	ITKDataBlockHandle

typedef boost::shared_ptr< ITKDataBlockPrivate >	ITKDataBlockPrivateHandle

typedef boost::shared_ptr< ITKImage2DData >	ITKImage2DDataHandle

typedef ITKImage2DDataT< signed char >	ITKCharImage2DData

typedef ITKImage2DDataT< unsigned char >	ITKUCharImage2DData

typedef ITKImage2DDataT< signed short >	ITKShortImage2DData

typedef ITKImage2DDataT< unsigned short >	ITKUShortImage2DData

typedef ITKImage2DDataT< signed int >	ITKIntImage2DData

typedef ITKImage2DDataT< unsigned int >	ITKUIntImage2DData

typedef ITKImage2DDataT< float >	ITKFloatImage2DData

typedef ITKImage2DDataT< double >	ITKDoubleImage2DData

typedef ITKCharImage2DData::handle_type	ITKCharImage2DDataHandle

typedef ITKUCharImage2DData::handle_type	ITKUCharImage2DDataHandle

typedef ITKShortImage2DData::handle_type	ITKShortImage2DDataHandle

typedef ITKUShortImage2DData::handle_type	ITKUShortImage2DDataHandle

typedef ITKIntImage2DData::handle_type	ITKIntImage2DDataHandle

typedef ITKUIntImage2DData::handle_type	ITKUIntImage2DDataHandle

typedef ITKFloatImage2DData::handle_type	ITKFloatImage2DDataHandle

typedef ITKDoubleImage2DData::handle_type	ITKDoubleImage2DDataHandle

typedef boost::shared_ptr< ITKImageData >	ITKImageDataHandle

typedef ITKImageDataT< signed char >	ITKCharImageData

typedef ITKImageDataT< unsigned char >	ITKUCharImageData

typedef ITKImageDataT< signed short >	ITKShortImageData

typedef ITKImageDataT< unsigned short >	ITKUShortImageData

typedef ITKImageDataT< signed int >	ITKIntImageData

typedef ITKImageDataT< unsigned int >	ITKUIntImageData

typedef ITKImageDataT< float >	ITKFloatImageData

typedef ITKImageDataT< double >	ITKDoubleImageData

typedef ITKCharImageData::handle_type	ITKCharImageDataHandle

typedef ITKUCharImageData::handle_type	ITKUCharImageDataHandle

typedef ITKShortImageData::handle_type	ITKShortImageDataHandle

typedef ITKUShortImageData::handle_type	ITKUShortImageDataHandle

typedef ITKIntImageData::handle_type	ITKIntImageDataHandle

typedef ITKUIntImageData::handle_type	ITKUIntImageDataHandle

typedef ITKFloatImageData::handle_type	ITKFloatImageDataHandle

typedef ITKDoubleImageData::handle_type	ITKDoubleImageDataHandle

typedef boost::shared_ptr< MaskDataBlock >	MaskDataBlockHandle

typedef boost::weak_ptr< MaskDataBlock >	MaskDataBlockWeakHandle

typedef boost::shared_ptr< MaskDataBlockManagerInternal >	MaskDataBlockManagerInternalHandle

typedef boost::shared_ptr< MaskDataSlice >	MaskDataSliceHandle

typedef boost::weak_ptr< MaskDataSlice >	MaskDataSliceWeakHandle

typedef boost::shared_ptr< NrrdData >	NrrdDataHandle

typedef boost::shared_ptr< NrrdDataPrivate >	NrrdDataPrivateHandle

typedef boost::shared_ptr< NrrdDataBlock >	NrrdDataBlockHandle

typedef boost::shared_ptr< NrrdDataBlockPrivate >	NrrdDataBlockPrivateHandle

typedef boost::shared_ptr< StdDataBlock >	StdDataBlockHandle

typedef boost::shared_ptr< DefaultEventHandlerContextPrivate >	DefaultEventHandlerContextPrivateHandle

typedef boost::shared_ptr< EventSync >	EventSyncHandle
	Define an Application Event Sync type handle.

typedef boost::shared_ptr< Event >	EventHandle

typedef boost::shared_ptr< EventHandler >	EventHandlerHandle

typedef boost::shared_ptr< EventHandlerContext >	EventHandlerContextHandle

typedef boost::shared_ptr< BufferObject >	BufferObjectHandle

typedef boost::shared_ptr< ColorMap >	ColorMapHandle

typedef boost::shared_ptr< ColorMapPrivate >	ColorMapPrivateHandle

typedef boost::shared_ptr< FramebufferObject >	FramebufferObjectHandle

typedef boost::shared_ptr< GLSLProgram >	GLSLProgramHandle

typedef boost::shared_ptr< GLSLShader >	GLSLShaderHandle

typedef boost::shared_ptr< PixelBufferObject >	PixelBufferObjectHandle

typedef boost::shared_ptr< Renderbuffer >	RenderbufferHandle

typedef boost::shared_ptr< ShaderBasePrivate >	ShaderBasePrivateHandle

typedef boost::shared_ptr< Texture >	TextureHandle

typedef boost::shared_ptr< Texture1D >	Texture1DHandle

typedef boost::shared_ptr< Texture2D >	Texture2DHandle

typedef boost::shared_ptr< Texture3D >	Texture3DHandle

typedef boost::shared_ptr< UnitCube >	UnitCubeHandle

typedef boost::shared_ptr< VertexBufferObject >	VertexBufferObjectHandle

typedef boost::shared_ptr< VertexAttribArrayBuffer >	VertexAttribArrayBufferHandle

typedef boost::shared_ptr< ElementArrayBuffer >	ElementArrayBufferHandle

typedef boost::shared_ptr< InterfacePrivate >	InterfacePrivateHandle

typedef boost::shared_ptr< InterfaceActionContext >	InterfaceActionContextHandle

typedef boost::shared_ptr< VertexBufferBatch >	VertexBufferBatchHandle

typedef boost::shared_ptr< Isosurface >	IsosurfaceHandle

typedef boost::shared_ptr< IsosurfacePrivate >	IsosurfacePrivateHandle

typedef std::vector< unsigned int >	UIntVector

typedef std::vector< float >	FloatVector

typedef std::vector< PointF >	PointFVector

typedef std::vector< VectorF >	VectorFVector

typedef std::vector< unsigned char >	UCharVector

typedef std::vector< size_t >	IVector

typedef std::map< std::string, std::string >	FilterMap

typedef boost::shared_ptr< LargeVolumeCache >	LargeVolumeCacheHandle

typedef boost::shared_ptr< LargeVolumeCachePrivate >	LargeVolumeCachePrivateHandle

typedef boost::shared_ptr< LargeVolumeBrickLevel >	LargeVolumeBrickLevelHandle

typedef boost::shared_ptr< LargeVolumeConverterPrivate >	LargeVolumeConverterPrivateHandle

typedef boost::shared_ptr< LargeVolumeConverter >	LargeVolumeConverterHandle

typedef boost::shared_ptr< LargeVolumeSchemaPrivate >	LargeVolumeSchemaPrivateHandle

typedef boost::shared_ptr< LargeVolumeSchema >	LargeVolumeSchemaHandle

typedef boost::shared_ptr< RolloverLogFilePrivate >	RolloverLogFilePrivateHandle

typedef boost::shared_ptr< ArrayMathEnginePrivate >	ArrayMathEnginePrivateHandle

typedef boost::shared_ptr< ArrayMathProgramPrivate >	ArrayMathProgramPrivateHandle

typedef boost::function< bool(ArrayMathProgramCode &pc) >	ArrayMathFunctionObject

typedef boost::shared_ptr< ArrayMathProgramSourcePrivate >	ArrayMathProgramSourcePrivateHandle

typedef boost::shared_ptr< ArrayMathProgramVariablePrivate >	ArrayMathProgramVariablePrivateHandle

typedef boost::shared_ptr< ParserPrivate >	ParserPrivateHandle

typedef boost::shared_ptr< ParserFunctionPrivate >	ParserFunctionPrivateHandle

typedef std::map< std::string, ParserFunction * >	ParserFunctionList

typedef boost::shared_ptr< ParserFunctionCatalogPrivate >	ParserFunctionCatalogPrivateHandle

typedef int	index_type

typedef int	size_type

typedef boost::shared_ptr< ArrayMathFunctionCatalog >	ArrayMathFunctionCatalogHandle

typedef boost::shared_ptr< ArrayMathProgram >	ArrayMathProgramHandle

typedef boost::shared_ptr< ArrayMathProgramVariable >	ArrayMathProgramVariableHandle

typedef boost::shared_ptr< ParserFunctionCatalog >	ParserFunctionCatalogHandle

typedef boost::shared_ptr< ParserNode >	ParserNodeHandle

typedef boost::shared_ptr< ParserProgram >	ParserProgramHandle

typedef boost::shared_ptr< ParserScriptFunction >	ParserScriptFunctionHandle

typedef boost::shared_ptr< ParserScriptVariable >	ParserScriptVariableHandle

typedef boost::shared_ptr< ParserTree >	ParserTreeHandle

typedef boost::shared_ptr< ParserVariable >	ParserVariableHandle

typedef std::map< std::string, ParserVariableHandle >	ParserVariableList

typedef boost::shared_ptr< ParserNodePrivate >	ParserNodePrivateHandle

typedef boost::shared_ptr< ParserProgramPrivate >	ParserProgramPrivateHandle

typedef boost::shared_ptr< ParserScriptFunctionPrivate >	ParserScriptFunctionPrivateHandle

typedef boost::shared_ptr< ParserScriptVariablePrivate >	ParserScriptVariablePrivateHandle

typedef boost::shared_ptr< ParserTreePrivate >	ParserTreePrivateHandle

typedef boost::shared_ptr< ParserVariablePrivate >	ParserVariablePrivateHandle

typedef boost::shared_ptr< PythonActionContext >	PythonActionContextHandle

typedef boost::shared_ptr< PythonInterpreterPrivate >	PythonInterpreterPrivateHandle

typedef boost::shared_ptr< AbstractRenderer >	AbstractRendererHandle

typedef boost::shared_ptr< PickPoint >	PickPointHandle

typedef boost::shared_ptr< RendererBase >	RendererBaseHandle

typedef boost::shared_ptr< RendererBasePrivate >	RendererBasePrivateHandle

typedef boost::shared_ptr< RenderContext >	RenderContextHandle

typedef boost::shared_ptr< RenderContextBinding >	RenderContextBindingHandle

typedef boost::shared_ptr< RenderResourcesPrivate >	RenderResourcesPrivateHandle

typedef boost::shared_ptr< RenderResourcesContext >	RenderResourcesContextHandle

typedef boost::shared_ptr< BooleanStateGroup >	BooleanStateGroupHandle

typedef boost::shared_ptr< BooleanStateGroupPrivate >	BooleanStateGroupPrivateHandle

typedef boost::shared_ptr< StateBase >	StateBaseHandle

typedef boost::weak_ptr< StateBase >	StateBaseWeakHandle

typedef boost::shared_ptr< StateBasePrivate >	StateBasePrivateHandle

typedef std::map< std::string, Core::AtomicCounterHandle >	state_handler_counter_map_type

typedef std::map< std::string, StateHandler * >	state_handler_map_type

typedef std::pair< int, std::string >	HandlerEntry

typedef std::map< std::string, StateBaseHandle >	state_map_type

typedef std::pair< std::string, StateBaseHandle >	StateEntry

typedef boost::shared_ptr< StateIOPrivate >	StateIOPrivateHandle

typedef boost::shared_ptr< StateLabeledMultiOption >	StateLabeledMultiOptionHandle

typedef boost::shared_ptr< StateLabeledMultiOptionPrivate >	StateLabeledMultiOptionPrivateHandle

typedef boost::shared_ptr< StateLabeledOption >	StateLabeledOptionHandle

typedef boost::shared_ptr< StateLabeledOptionPrivate >	StateLabeledOptionPrivateHandle

typedef std::pair< std::string, std::string >	OptionLabelPair

typedef std::vector< OptionLabelPair >	OptionLabelPairVector

typedef boost::shared_ptr< StateName >	StateNameHandle

typedef boost::shared_ptr< StateNamePrivate >	StateNamePrivateHandle

typedef boost::shared_ptr< StateOption >	StateOptionHandle

typedef boost::shared_ptr< StateRangedValueBase >	StateRangedValueBaseHandle

typedef boost::weak_ptr< StateRangedValueBase >	StateRangedValueBaseWeakHandle

typedef StateRangedValue< double >	StateRangedDouble

typedef boost::shared_ptr< StateRangedDouble >	StateRangedDoubleHandle

typedef StateRangedValue< int >	StateRangedInt

typedef boost::shared_ptr< StateRangedInt >	StateRangedIntHandle

typedef StateRangedValue< unsigned int >	StateRangedUInt

typedef boost::shared_ptr< StateRangedUInt >	StateRangedUIntHandle

typedef boost::shared_ptr< StateSetBase >	StateSetBaseHandle

typedef boost::weak_ptr< StateSetBase >	StateSetBaseWeakHandle

typedef StateSet< int >	StateIntSet

typedef boost::shared_ptr< StateIntSet >	StateIntSetHandle

typedef StateValue< double >	StateDouble

typedef boost::shared_ptr< StateDouble >	StateDoubleHandle

typedef boost::weak_ptr< StateDouble >	StateDoubleWeakHandle

typedef StateValue< Point >	StatePoint

typedef boost::shared_ptr< StatePoint >	StatePointHandle

typedef boost::weak_ptr< StatePoint >	StatePointWeakHandle

typedef StateValue< Color >	StateColor

typedef boost::shared_ptr< StateColor >	StateColorHandle

typedef boost::weak_ptr< StateColor >	StateColorWeakHandle

typedef StateValue< bool >	StateBool

typedef boost::shared_ptr< StateBool >	StateBoolHandle

typedef boost::weak_ptr< StateBool >	StateBoolWeakHandle

typedef StateValue< int >	StateInt

typedef boost::shared_ptr< StateInt >	StateIntHandle

typedef boost::weak_ptr< StateInt >	StateIntWeakHandle

typedef StateValue< unsigned int >	StateUInt

typedef boost::shared_ptr< StateInt >	StateUIntHandle

typedef boost::weak_ptr< StateInt >	StateUIntWeakHandle

typedef StateValue< long long >	StateLongLong

typedef boost::shared_ptr< StateLongLong >	StateLongLongHandle

typedef boost::weak_ptr< StateLongLong >	StateLongLongWeakHandle

typedef StateValue< std::string >	StateString

typedef boost::shared_ptr< StateString >	StateStringHandle

typedef boost::weak_ptr< StateString >	StateStringWeakHandle

typedef StateValue< Path >	StateSpeedlinePath

typedef boost::shared_ptr< StateSpeedlinePath >	StateSpeedlinePathHandle

typedef StateValue< BBox >	StateBBox

typedef boost::shared_ptr< StateBBox >	StateBBoxHandle

typedef StateValue< GridTransform >	StateGridTransform

typedef boost::shared_ptr< StateGridTransform >	StateGridTransformHandle

typedef boost::shared_ptr< StateVectorBase >	StateVectorBaseHandle

typedef boost::weak_ptr< StateVectorBase >	StateVectorBaseWeakHandle

typedef StateVector< Point >	StatePointVector

typedef boost::shared_ptr< StatePointVector >	StatePointVectorHandle

typedef StateVector< Color >	StateColorVector

typedef boost::shared_ptr< StateColorVector >	StateColorVectorHandle

typedef Core::StateVector< Measurement >	StateMeasurementVector

typedef boost::shared_ptr< StateMeasurementVector >	StateMeasurementVectorHandle

typedef StateVector< bool >	StateBoolVector

typedef boost::shared_ptr< StateBoolVector >	StateBoolVectorHandle

typedef StateVector< int >	StateIntVector

typedef boost::shared_ptr< StateIntVector >	StateIntVectorHandle

typedef StateVector< double >	StateDoubleVector

typedef boost::shared_ptr< StateDoubleVector >	StateDoubleVectorHandle

typedef StateVector< std::string >	StateStringVector

typedef boost::shared_ptr< StateStringVector >	StateStringVectorHandle

typedef boost::shared_ptr< StateView2D >	StateView2DHandle

typedef boost::weak_ptr< StateView2D >	StateView2DWeakHandle

typedef boost::shared_ptr< StateView3D >	StateView3DHandle

typedef boost::weak_ptr< StateView3D >	StateView3DWeakHandle

typedef boost::shared_ptr< StateViewBase >	StateViewBaseHandle

typedef boost::weak_ptr< StateViewBase >	StateViewBaseWeakHandle

typedef boost::shared_ptr< FreeTypeFace >	FreeTypeFaceHandle

typedef boost::shared_ptr< FreeTypeGlyph >	FreeTypeGlyphHandle

typedef boost::shared_ptr< const FreeTypeGlyph >	FreeTypeGlyphConstHandle

typedef boost::shared_ptr< FreeTypeBitmapGlyph >	FreeTypeBitmapGlyphHandle

typedef boost::shared_ptr< FreeTypeLibrary >	FreeTypeLibraryHandle

typedef boost::shared_ptr< TextRenderer >	TextRendererHandle

typedef boost::shared_ptr< AtomicCounter >	AtomicCounterHandle

typedef boost::shared_ptr< ConnectionHandlerPrivate >	ConnectionHandlerPrivateHandle

typedef boost::shared_ptr< ConnectionHandlerConnection >	ConnectionHandlerConnectionHandle

typedef ConnectionHandlerConnectionHandle	ConnectionHandle

typedef boost::shared_ptr< Notifier >	NotifierHandle

typedef boost::shared_ptr< ParallelPrivate >	ParallelPrivateHandle

typedef boost::shared_ptr< Runnable >	RunnableHandle

typedef std::vector< std::string >	StringVector

typedef boost::shared_ptr< StringVector >	StringVectorHandle

typedef boost::shared_ptr< const StringVector >	StringVectorConstHandle

typedef std::list< std::string >	StringList

typedef boost::shared_ptr< StringList >	StringListHandle

typedef boost::shared_ptr< const StringList >	StringListConstHandle

typedef boost::shared_ptr< Timer >	TimerHandle

typedef boost::shared_ptr< TimerPrivate >	TimerPrivateHandle

typedef boost::shared_ptr< VariantBase >	VariantBaseHandle

typedef boost::shared_ptr< AbstractViewer >	AbstractViewerHandle

typedef boost::weak_ptr< AbstractViewer >	AbstractViewerWeakHandle

typedef boost::shared_ptr< AbstractViewerPrivate >	AbstractViewerPrivateHandle

typedef boost::shared_ptr< MousePosition >	MousePositionHandle

typedef boost::shared_ptr< DataVolume >	DataVolumeHandle

typedef boost::weak_ptr< DataVolume >	DataVolumeWeakHandle

typedef boost::shared_ptr< DataVolumePrivate >	DataVolumePrivateHandle

typedef boost::shared_ptr< DataVolumeBrick >	DataVolumeBrickHandle

typedef boost::shared_ptr< DataVolumeBrickPrivate >	DataVolumeBrickPrivateHandle

typedef boost::shared_ptr< DataVolumeSlice >	DataVolumeSliceHandle

typedef boost::shared_ptr< DataVolumeSlicePrivate >	DataVolumeSlicePrivateHandle

typedef boost::shared_ptr< LargeVolume >	LargeVolumeHandle

typedef boost::shared_ptr< LargeVolumePrivate >	LargeVolumePrivateHandle

typedef boost::shared_ptr< LargeVolumeBrickSlice >	LargeVolumeBrickSliceHandle

typedef boost::shared_ptr< LargeVolumeBrickSlicePrivate >	LargeVolumeBrickSlicePrivateHandle

typedef boost::shared_ptr< LargeVolumeSlice >	LargeVolumeSliceHandle

typedef boost::shared_ptr< LargeVolumeSlicePrivate >	LargeVolumeSlicePrivateHandle

typedef boost::shared_ptr< MaskVolume >	MaskVolumeHandle

typedef boost::weak_ptr< MaskVolume >	MaskVolumeWeakHandle

typedef boost::shared_ptr< MaskVolumeSlice >	MaskVolumeSliceHandle

typedef boost::shared_ptr< MaskVolumeSlicePrivate >	MaskVolumeSlicePrivateHandle

typedef boost::shared_ptr< Volume >	VolumeHandle

typedef boost::weak_ptr< Volume >	VolumeWeakHandle

typedef SliceType	VolumeSliceType

typedef boost::shared_ptr< VolumeSlice >	VolumeSliceHandle

typedef boost::shared_ptr< VolumeSlicePrivate >	VolumeSlicePrivateHandle

typedef std::map< std::string, TransferFunctionFeatureHandle >	tf_feature_map_type

typedef boost::shared_ptr< TransferFunction >	TransferFunctionHandle

typedef boost::shared_ptr< TransferFunction const >	TransferFunctionConstHandle

typedef boost::shared_ptr< TransferFunctionPrivate >	TransferFunctionPrivateHandle

typedef std::vector< TransferFunctionControlPoint >	TransferFunctionControlPointVector

typedef StateVector< TransferFunctionControlPoint >	StateTransferFunctionControlPointVector

typedef boost::shared_ptr< StateTransferFunctionControlPointVector >	StateTransferFunctionControlPointVectorHandle

typedef boost::shared_ptr< TransferFunctionFeature >	TransferFunctionFeatureHandle

typedef boost::shared_ptr< TransferFunctionFeaturePrivate >	TransferFunctionFeaturePrivateHandle

typedef boost::shared_ptr< VolumeRendererBase >	VolumeRendererBaseHandle

typedef boost::shared_ptr< VolumeRendererBasePrivate >	VolumeRendererBasePrivateHandle

typedef boost::shared_ptr< VolumeRendererOcclusion >	VolumeRendererOcclusionHandle

typedef boost::shared_ptr< VolumeRendererOcclusionPrivate >	VolumeRendererOcclusionPrivateHandle

typedef boost::shared_ptr< VolumeRendererSimple >	VolumeRendererSimpleHandle

typedef boost::shared_ptr< VolumeRendererSimplePrivate >	VolumeRendererSimplePrivateHandle

typedef boost::shared_ptr< VolumeShaderOcclusion >	VolumeShaderOcclusionHandle

typedef boost::shared_ptr< VolumeShaderSimple >	VolumeShaderSimpleHandle

Enumerations
enum	{ SCRIPT_SEQUENTIAL_VAR_E = 1, SCRIPT_SINGLE_VAR_E = 2, SCRIPT_CONST_VAR_E = 4, SCRIPT_USED_VAR_E = 8, SCRIPT_OPTIONAL_VAR_E = 16 }

enum	{ PARSER_CONSTANT_SCALAR_E = 1, PARSER_CONSTANT_STRING_E = 2, PARSER_VARIABLE_E = 3, PARSER_FUNCTION_E = 4 }

enum	{ PARSER_SEQUENTIAL_FUNCTION_E = 1, PARSER_SINGLE_FUNCTION_E = 2, PARSER_CONST_FUNCTION_E = 4, PARSER_SYMMETRIC_FUNCTION_E = 16 }

enum	{ SCRIPT_INPUT_E = 1, SCRIPT_OUTPUT_E = 2, SCRIPT_CONSTANT_SCALAR_E = 4, SCRIPT_CONSTANT_STRING_E = 8, SCRIPT_VARIABLE_E = 16 }

Functions
	CORE_ENUM_CLASS (ActionStatus, SUCCESS_E=0, ERROR_E=1, INVALID_E=2, UNAVAILABLE_E=3) CORE_ENUM_CLASS(ActionSource
	This enum lists the possible outcomes of preforming an action. More...

	CORE_SINGLETON_IMPLEMENTATION (ActionDispatcher)

	CORE_SINGLETON_IMPLEMENTATION (ActionFactory)

	CORE_SINGLETON_IMPLEMENTATION (ActionHistory)

	CORE_SINGLETON_IMPLEMENTATION (Application)

void	SwapEndian (void *data, size_t size, size_t elem_size)

template<class T >
bool	ExtractSliceInternal (DataBlock *volume_data_block, DataSliceHandle &slice, SliceType type, DataBlock::index_type index)

template<class T >
bool	InsertSliceInternal (DataBlock *volume_data_block, const DataSliceHandle &slice)

template<class T >
bool	PadInternal (DataBlockHandle src, DataBlockHandle dst, int pad, double val)

template<class T >
bool	ClipInternal (DataBlockHandle src, DataBlockHandle dst, double val)

	CORE_SINGLETON_IMPLEMENTATION (DataBlockManager)

bool	ImportFromString (const std::string &data_type_string, DataType &data_type)

std::string	ExportToString (DataType data_type)
	This class describes the data types that the program uses. More...

int	GetNrrdDataType (const DataType &data_type)
	Get the type of the data.

size_t	GetSizeDataType (const DataType &data_type)
	Get the number of bytes in this data type.

bool	IsInteger (const DataType &data_type)
	Test whether data type is an integer.

bool	IsReal (const DataType &data_type)
	Test whether data is floating point.

DataType	GetDataType (signed char *)
	Get the data type from a pointer to the type.

DataType	GetDataType (unsigned char *)

DataType	GetDataType (short *)

DataType	GetDataType (unsigned short *)

DataType	GetDataType (int *)

DataType	GetDataType (unsigned int *)

DataType	GetDataType (long long *)

DataType	GetDataType (unsigned long long *)

DataType	GetDataType (float *)

DataType	GetDataType (double *)

std::string	ExportToString (const Histogram &value)
	Put the contents of the histogram into a string.

bool	ImportFromString (const std::string &str, Histogram &value)
	Import the histogram from a string and return true if the conversion succeeded.

	CORE_SINGLETON_IMPLEMENTATION (MaskDataBlockManager)

template<class T >
bool	ConvertToMaskInternal (DataBlockHandle data, MaskDataBlockHandle &mask, bool invert)

template<class T >
bool	ConvertToMaskLargerThanInternal (DataBlockHandle data, MaskDataBlockHandle &mask, bool invert)

template<class T >
bool	ConvertLabelToMaskInternal (DataBlockHandle data, MaskDataBlockHandle &mask, double label)

template<class T >
bool	ConvertLabelToDataInternal (MaskDataBlockHandle mask, DataBlockHandle &data, double label)

template<class T >
bool	ConvertToDataInternal (MaskDataBlockHandle mask, DataBlockHandle &data, bool invert)

template<class T >
bool	InscribeInternal (MaskDataBlockHandle mask, DataBlockHandle data, double label, bool invert)

void	TerminateEventHandlerThread (EventHandlerHandle handle)

void	TerminateEventHandler (EventHandlerHandle &handle)

double	DistanceToLine2 (const Point &p, const Point &a, const Point &b, const double epsilon)

void	DistanceToLine2Aux (Point &result, const Point &p, const Point &a, const Point &b, const double epsilon)

void	DistanceToLine2Aux (Point &result, int &node, const Point &p, const Point &a, const Point &b, const double epsilon)

template<class T >
T	SolveMatrix3x3 (const T p, const T q, T *r)

bool	RayTriangleIntersection (Point &result, const Point &orig, const Vector &dir, const Point &p0, const Point &p1, const Point &p2)

void	ClosestPointOnTriangle (Point &result, const Point &orig, const Point &p0, const Point &p1, const Point &p2, const double epsilon)

void	ClosestPointOnTriangle (Point &result, int &edge, int &node, const Point &orig, const Point &p0, const Point &p1, const Point &p2, const double epsilon)

void	EstimateClosestPointOnQuad (Point &result, const Point &orig, const Point &p0, const Point &p1, const Point &p2, const Point &p3, const double epsilon)

double	RayPlaneIntersection (const Point &p, const Vector &dir, const Point &p0, const Vector &pn, const double epsilon)

bool	RayTriangleIntersection (double &t, double &u, double &v, bool backface_cull, const Point &orig, const Vector &dir, const Point &p0, const Point &p1, const Point &p2, const double epsilon)

bool	ClosestLineToLine (double &s, double &t, const Point &a0, const Point &a1, const Point &b0, const Point &b1, const double epsilon)

double	TetrahedraVolume (const Point &p0, const Point &p1, const Point &p2, const Point &p3)

void	TriangleTriangleIntersection (const Point &A0, const Point &A1, const Point &A2, const Point &B0, const Point &B1, const Point &B2, std::vector< Point > &results)

std::string	ExportToString (const BBox &value)

bool	ImportFromString (const std::string &str, BBox &value)

	CORE_ENUM_CLASS (IntersectionType, INSIDE_E=1, INTERSECT_E=0, OUTSIDE_E=-1) class BBox

Color	operator* (float alpha, Color color)

std::string	ExportToString (const Color &value)

bool	ImportFromString (const std::string &str, Color &value)

Point	operator* (const GridTransform &gt, const Point &d)

Vector	operator* (const GridTransform &gt, const Vector &d)

PointF	operator* (const GridTransform &gt, const PointF &d)

VectorF	operator* (const GridTransform &gt, const VectorF &d)

std::ostream &	operator<< (std::ostream &os, const GridTransform &gt)

std::string	ExportToString (const GridTransform &value)

bool	ImportFromString (const std::string &str, GridTransform &value)

std::ostream &	operator<< (std::ostream &os, const IndexVector &idx)
	Import/Export functions.

std::string	ExportToString (const IndexVector &idx)

bool	ImportFromString (const std::string &str, IndexVector &idx)

std::string	ExportToString (const Measurement &value)

std::string	ExportToString (const std::vector< Measurement > &value)

bool	ImportFromString (const std::string &str, Measurement &value)

bool	ImportFromString (const std::string &str, std::vector< Measurement > &value)

std::string	ExportToString (const SinglePath &value)

std::string	ExportToString (const Path &value)

bool	ImportFromString (const std::string &str, SinglePath &value)

bool	ImportFromString (const std::string &str, Path &value)

std::string	ExportToString (const Plane &value)

bool	ImportFromString (const std::string &str, Plane &value)

PointF	AffineCombination (const PointF &p1, float w1, const PointF &p2, float w2)

PointF	AffineCombination (const PointF &p1, float w1, const PointF &p2, float w2, const PointF &p3, float w3)

PointF	AffineCombination (const PointF &p1, float w1, const PointF &p2, float w2, const PointF &p3, float w3, const PointF &p4, float w4)

Point	AffineCombination (const Point &p1, double w1, const Point &p2, double w2)

Point	AffineCombination (const Point &p1, double w1, const Point &p2, double w2, const Point &p3, double w3)

Point	AffineCombination (const Point &p1, double w1, const Point &p2, double w2, const Point &p3, double w3, const Point &p4, double w4)

std::ostream &	operator<< (std::ostream &os, const Point &p)

std::ostream &	operator<< (std::ostream &os, const PointF &p)

std::string	ExportToString (const Point &value)

std::string	ExportToString (const PointF &value)

std::string	ExportToString (const std::vector< Point > &value)

std::string	ExportToString (const std::vector< PointF > &value)

bool	ImportFromString (const std::string &str, Point &value)

bool	ImportFromString (const std::string &str, PointF &value)

bool	ImportFromString (const std::string &str, std::vector< Point > &value)

bool	ImportFromString (const std::string &str, std::vector< PointF > &value)

Point	operator* (double d, const Point &point)

PointF	operator* (float f, const PointF &point)

Point	Interpolate (const Point &v1, const Point &v2, double weight)

PointF	Interpolate (const PointF &v1, const PointF &v2, float weight)

Point	Min (const Point &p1, const Point &p2)

Point	Max (const Point &p1, const Point &p2)

PointF	Min (const PointF &p1, const PointF &p2)

PointF	Max (const PointF &p1, const PointF &p2)

double	Dot (const Point &p, const Vector &v)

double	Dot (const Point &p1, const Point &p2)

double	Dot (const Vector &p1, const Point &p2)

float	Dot (const PointF &p, const VectorF &v)

float	Dot (const PointF &p1, const PointF &p2)

float	Dot (const VectorF &p1, const PointF &p2)

Quaternion	Slerp (const Quaternion &from, const Quaternion &to, double t, bool shortest_path)

std::string	ExportToString (const Quaternion &value)

bool	ImportFromString (const std::string &str, Quaternion &value)

Point	operator* (const Transform &t, const Point &d)

Vector	operator* (const Transform &t, const Vector &d)

PointF	operator* (const Transform &t, const PointF &d)

VectorF	operator* (const Transform &t, const VectorF &d)

std::string	ExportToString (const Transform &value)

bool	ImportFromString (const std::string &str, Transform &value)

Point	operator* (const TransformF &t, const Point &d)

Vector	operator* (const TransformF &t, const Vector &d)

PointF	operator* (const TransformF &t, const PointF &d)

VectorF	operator* (const TransformF &t, const VectorF &d)

std::ostream &	operator<< (std::ostream &os, const Transform &t)

std::ostream &	operator<< (std::ostream &os, const TransformF &t)

std::string	ExportToString (const TransformF &value)

bool	ImportFromString (const std::string &str, TransformF &value)

std::ostream &	operator<< (std::ostream &os, const Vector &v)

std::ostream &	operator<< (std::ostream &os, const VectorF &v)

std::string	ExportToString (const Vector &value)

std::string	ExportToString (const VectorF &value)

std::string	ExportToString (const std::vector< Vector > &value)

std::string	ExportToString (const std::vector< VectorF > &value)

bool	ImportFromString (const std::string &str, Vector &value)

bool	ImportFromString (const std::string &str, VectorF &value)

bool	ImportFromString (const std::string &str, std::vector< Vector > &value)

bool	ImportFromString (const std::string &str, std::vector< VectorF > &value)

Vector	operator* (const double s, const Vector &v)

VectorF	operator* (const float s, const VectorF &v)

Vector	Abs (const Vector &v)

VectorF	Abs (const VectorF &v)

Vector	Cross (const Vector &v1, const Vector &v2)

VectorF	Cross (const VectorF &v1, const VectorF &v2)

Vector	Interpolate (const Vector &v1, const Vector &v2, double weight)

VectorF	Interpolate (const VectorF &v1, const VectorF &v2, float weight)

double	Dot (const Vector &v1, const Vector &v2)

float	Dot (const VectorF &v1, const VectorF &v2)

Vector	Min (const Vector &v1, const Vector &v2)

VectorF	Min (const VectorF &v1, const VectorF &v2)

VectorF	Max (const VectorF &v1, const VectorF &v2)

std::string	ExportToString (const View2D &value)

bool	ImportFromString (const std::string &str, View2D &value)

std::string	ExportToString (const View3D &value)

bool	ImportFromString (const std::string &str, View3D &value)

template<class T >
void	SetPixel (T *buffer, const int width, const int x, const int y, const T value)

template<class T >
void	FloodFill (T *buffer, const int width, const int height, const int x, const int y, const T value)

template<class T , class FUNCTOR >
void	FloodFill (T *buffer, const int width, const int height, const int x, const int y, const T value, FUNCTOR condition)

	CORE_ENUM_CLASS (VertexAttribArrayType, VERTEX_E=0, COLOR_E, TEXTURE_COORD_E, SECONDARY_COLOR_E, NORMAL_E, FOG_COORD_E, INDEX_E, EDGE_FLAG_E) class VertexBufferObject

	CORE_SINGLETON_IMPLEMENTATION (Interface)

boost::shared_array< float >	computeFaceNormal (const PointF &p1, const PointF &p2, const PointF &p3)

	CORE_SINGLETON_IMPLEMENTATION (LargeVolumeCache)

template<class T >
T	Min (T d1, T d2)

template<class T >
T	Max (T d1, T d2)

template<class T >
T	Min (T d1, T d2, T d3)

template<class T >
T	Mid (T d1, T d2, T d3)

template<class T >
T	Max (T d1, T d2, T d3)

double	Pow (double value, double power)

double	Pow (double value, int power)

float	Pow (float value, float power)

float	Pow (float value, int power)

double	Sqrt (double value)

float	Sqrt (float value)

double	Cbrt (double value)

float	Cbrt (float value)

template<class T >
T	Sqr (T value)

double	Exp (double value)

float	Exp (float value)

template<class T >
T	Abs (T value)

template<class T >
int	Sign (T value)

template<class T >
T	Clamp (T value, T min, T max)

template<class T , class G >
T	Interpolate (T value1, T value2, G weight)

template<class T >
T	Fraction (T value)

template<class T >
int	RoundDown (T value)

template<class T >
int	RoundUp (T value)

template<class T >
int	Round (T value)

template<class T >
int	Floor (T value)

template<class T >
int	Ceil (T value)

bool	IsNan (double val)

bool	IsInfinite (double val)

bool	IsFinite (double val)

double	Nan ()

double	Epsilon ()

bool	IsNan (float val)

bool	IsInfinite (float val)

bool	IsFinite (float val)

float	Nanf ()

float	Epsilonf ()

bool	IsPowerOf2 (size_t value)

size_t	NextPowerOf2 (size_t value)

size_t	LargestPowerOf2 (const size_t value)

double	Pi ()

float	Pif ()

double	Cos (double value)

double	Sin (double value)

double	Asin (double value)

double	Acos (double value)

double	Tan (double value)

double	Cot (double value)

double	Atan (double value)

double	Atan2 (double y, double x)

double	DegreeToRadian (double degree)

double	RadianToDegree (double radian)

float	Sin (float value)

float	Cos (float value)

float	Tan (float value)

float	Cot (float value)

float	Atan (float value)

float	Atan2 (float y, float x)

float	Acos (float value)

float	DegreeToRadian (float degree)

float	RadianToDegree (float radian)

size_t	RemoveRemainder8 (size_t size)

void	InsertBasicArrayMathFunctionCatalog (ArrayMathFunctionCatalogHandle &catalog)
	Insert the basic functions into the database.

void	InsertSourceSinkArrayMathFunctionCatalog (ArrayMathFunctionCatalogHandle &catalog)

void	InsertScalarArrayMathFunctionCatalog (ArrayMathFunctionCatalogHandle &catalog)

std::string	ParserFunctionID (std::string name)

std::string	ParserFunctionID (std::string name, std::string arg1)

std::string	ParserFunctionID (std::string name, std::string arg1, std::string arg2)

std::string	ParserFunctionID (std::string name, std::vector< std::string > args)

std::string	ParserFunctionID (std::string name, int arg1)

std::string	ParserFunctionID (std::string name, int arg1, int arg2)

std::string	ParserFunctionID (std::string name, std::vector< int > args)

std::string	ParserVariableType (std::string type)

	CORE_ENUM_CLASS (PythonActionMode, INTERACTIVE_E, BATCH_E, REPLAY_E) class PythonActionContext

	CORE_SINGLETON_IMPLEMENTATION (PythonInterpreter)

void	RegisterToPythonConverters ()

boost::python::object	RunActionFromPython (boost::python::tuple args, boost::python::dict kw_args)

	CORE_SINGLETON_IMPLEMENTATION (RenderResources)

	CORE_SINGLETON_IMPLEMENTATION (StateEngine)

bool	operator< (const HandlerEntry &left, const HandlerEntry &right)

bool	operator> (const HandlerEntry &left, const HandlerEntry &right)

const std::string	STATE_ELEMENT_NAME ("State")

bool	operator< (const StateEntry &left, const StateEntry &right)

	CORE_SINGLETON_IMPLEMENTATION (FreeTypeLibraryFactory)

	CORE_ENUM_CLASS (TextHAlignmentType, LEFT_E, RIGHT_E, CENTER_E) CORE_ENUM_CLASS(TextVAlignmentType

bool	CreateOrIgnoreDirectory (const boost::filesystem::path &dir_path)

bool	RecursiveCopyDirectory (const boost::filesystem::path &from, const boost::filesystem::path &to)

std::tuple< std::string, std::string >	GetFullExtension (const boost::filesystem::path &filename)
	Detect and return file extension with multiple components (compressed, usually).

void	intrusive_ptr_add_ref (IntrusiveBase *object)

void	intrusive_ptr_release (IntrusiveBase *object)

	CORE_SINGLETON_IMPLEMENTATION (Log)

void	ExecuteRunnable (RunnableHandle runnable)

bool	ScanCommand (const std::string &str, std::string::size_type &start, std::string &command, std::string &error)

bool	ScanValue (const std::string &str, std::string::size_type &start, std::string &value, std::string &error)

bool	ScanKeyValuePair (const std::string &str, std::string::size_type &start, std::string &key, std::string &value, std::string &error)

template<class T >
bool	FromString (const std::string &str, T &value)

template<class T >
bool	MultipleFromString (const std::string &str, std::vector< T > &values)

template<class T >
std::string	ToString (T val)

std::string	ToString (float val)

std::string	ToString (double val)

std::string	ToString (const std::string &value)

template<class T >
std::string	ToString (T val, int precision)

std::string	ToString (unsigned char val, int precision)

std::string	ToString (unsigned short val, int precision)

std::string	ToString (unsigned int val, int precision)

std::string	ToString (unsigned long long val, int precision)

std::string	ToString (float val, int precision)

std::string	ToString (double val, int precision)

std::string	ToString (double val, size_t digits)

template<class CONTAINER_TYPE >
std::string	MultipleToString (const CONTAINER_TYPE &values)

std::string	StringToUpper (std::string str)

std::string	StringToLower (std::string str)

bool	FromString (const std::string &str, unsigned int &value)

bool	FromString (const std::string &str, double &value)

bool	FromString (const std::string &str, float &value)

void	StripSpaces (std::string &str)

void	StripSurroundingSpaces (std::string &str)

std::vector< std::string >	SplitString (const std::string &str, const std::string &delimiter)

void	AppendSpaceSplitSubstring (std::string str, size_t string_start, size_t string_end, std::vector< std::string > &value)

std::vector< std::string >	SplitStringByBracketsThenSpaces (const std::string &str)

std::string	ExportToString (bool value)

std::string	ExportToString (char value)

std::string	ExportToString (unsigned char value)

std::string	ExportToString (short value)

std::string	ExportToString (unsigned short value)

std::string	ExportToString (int value)

std::string	ExportToString (unsigned int value)

std::string	ExportToString (long value)

std::string	ExportToString (unsigned long value)

std::string	ExportToString (long long value)

std::string	ExportToString (unsigned long long value)

std::string	ExportToString (float value)

std::string	ExportToString (double value)

std::string	ExportToString (unsigned char value, int precision)

std::string	ExportToString (unsigned short value, int precision)

std::string	ExportToString (unsigned int value, int precision)

std::string	ExportToString (unsigned long long value, int precision)

std::string	ExportToString (float value, int precision)

std::string	ExportToString (double value, int precision)

std::string	ExportToString (const double &value, size_t digits)

std::string	ExportToString (const std::string &value)

std::string	ExportToString (const std::vector< char > &value)

std::string	ExportToString (const std::vector< std::string > &value)

std::string	ExportToString (const std::vector< unsigned char > &value)

std::string	ExportToString (const std::vector< short > &value)

std::string	ExportToString (const std::vector< unsigned short > &value)

std::string	ExportToString (const std::vector< int > &value)

std::string	ExportToString (const std::vector< unsigned int > &value)

std::string	ExportToString (const std::vector< long > &value)

std::string	ExportToString (const std::vector< unsigned long > &value)

std::string	ExportToString (const std::vector< long long > &value)

std::string	ExportToString (const std::vector< unsigned long long > &value)

std::string	ExportToString (const std::vector< float > &value)

std::string	ExportToString (const std::vector< double > &value)

std::string	ExportToString (const std::set< int > &value)

std::string	ExportToString (const std::vector< float > &value, int precision)

std::string	ExportToString (const std::vector< double > &value, int precision)

bool	ImportFromString (const std::string &str, bool &value)

bool	ImportFromString (const std::string &str, char &value)

bool	ImportFromString (const std::string &str, unsigned char &value)

bool	ImportFromString (const std::string &str, short &value)

bool	ImportFromString (const std::string &str, unsigned short &value)

bool	ImportFromString (const std::string &str, int &value)

bool	ImportFromString (const std::string &str, unsigned int &value)

bool	ImportFromString (const std::string &str, long &value)

bool	ImportFromString (const std::string &str, unsigned long &value)

bool	ImportFromString (const std::string &str, long long &value)

bool	ImportFromString (const std::string &str, unsigned long long &value)

bool	ImportFromString (const std::string &str, float &value)

bool	ImportFromString (const std::string &str, double &value)

bool	ImportFromString (const std::string &str, std::vector< char > &value)

bool	ImportFromString (const std::string &str, std::vector< unsigned char > &value)

bool	ImportFromString (const std::string &str, std::vector< short > &value)

bool	ImportFromString (const std::string &str, std::vector< unsigned short > &value)

bool	ImportFromString (const std::string &str, std::vector< int > &value)

bool	ImportFromString (const std::string &str, std::vector< unsigned int > &value)

bool	ImportFromString (const std::string &str, std::vector< long > &value)

bool	ImportFromString (const std::string &str, std::vector< unsigned long > &value)

bool	ImportFromString (const std::string &str, std::vector< long long > &value)

bool	ImportFromString (const std::string &str, std::vector< unsigned long long > &value)

bool	ImportFromString (const std::string &str, std::vector< float > &value)

bool	ImportFromString (const std::string &str, std::vector< double > &value)

bool	ImportFromString (const std::string &str, std::vector< std::string > &value)

bool	ImportFromString (const std::string &str, std::string &value)

bool	ImportFromString (const std::string &str, std::set< int > &value)

std::string	ExportToString (const Variant &variant)

bool	ImportFromString (const std::string &str, Variant &variant)

	CORE_ENUM_CLASS (MouseButton, NO_BUTTON_E=0x00000000, LEFT_BUTTON_E=0x00000001, RIGHT_BUTTON_E=0x00000002, MID_BUTTON_E=0x00000004) CORE_ENUM_CLASS(KeyModifier

template<class TYPE1 , class TYPE2 >
void	CopyTypedData (DataVolumeSlice slice, TYPE1 buffer, DataBlock *data_block)

template<class T >
void	ThresholdTypedData (const DataVolumeSlice slice, DataBlock data_block, unsigned char *buffer, double min_val, double max_val, bool negative_constraint)

std::string	ExportToString (const TransferFunctionControlPointVector &control_points)
	Export a vector of control points to string.

std::string	ExportToString (const TransferFunctionControlPoint &control_point)
	Export a control points to string.

bool	ImportFromString (const std::string &str, TransferFunctionControlPointVector &control_points)

bool	ImportFromString (const std::string &str, TransferFunctionControlPoint &control_point)

Variables
	NONE_E = 0
	NONE_E - It did not result from an action.

	INTERFACE_WIDGET_E = 1

	INTERFACE_MOUSE_E = 2

	INTERFACE_KEYBOARD_E = 3

	INTERFACE_MENU_E = 4
	INTERFACE_MENU_E - The action is run from the interface, through a menu.

	SCRIPT_E = 5

	COMMANDLINE_E = 6

	PROVENANCE_E = 7

	UNDOBUFFER_E
	UNDOBUFFER_E - The action is run from the undo buffer. More...

std::string	util_name_ = ""

const MarchingCubesTableType	MARCHING_CUBES_TABLE_C []

const CappingTableType	CAPPING_TABLE_C []

const ullong_float_type	nan_value_f

const ullong_float_type	inf_value_f

	BOTTOM_E

	TOP_E

	NO_MODIFIER_E = 0x00000000

	SHIFT_MODIFIER_E = 0x02000000

	CONTROL_MODIFIER_E = 0x04000000

	ALT_MODIFIER_E = 0x08000000

	META_MODIFIER_E = 0x10000000

	KEYPAD_MODIFIER_E = 0x20000000

	GROUPSWITCH_MODIFIER_E

Detailed Description

This vector type is similar in preformance to the StackVector, but checks for overflow. In case of overflow memory will be reserved to store data_

Typedef Documentation

typedef Variant Core::ActionResult

Class for returning the result of an action. As this needs to be a variant, each action may have a different result we currently typedef this to the ActionParameterVariant class

Enumeration Type Documentation

anonymous enum

Enumerator
SCRIPT_SEQUENTIAL_VAR_E	A sequence denotes a vectorized variable, hence when this flag is set the function will apply the function to an array, instead of a single variable
SCRIPT_SINGLE_VAR_E	Simple variable this is the default.
SCRIPT_CONST_VAR_E	Reserved for numerical constants.
SCRIPT_USED_VAR_E	Internal marker to mark which variables are actually used to compute the output.
SCRIPT_OPTIONAL_VAR_E	Internal marker telling an output is optional.

anonymous enum

Enumerator
PARSER_SEQUENTIAL_FUNCTION_E	Define a function as sequential it will be evaluted for each instance in the sequence. This one is used for functions without parameters like rand so they trigger for each case
PARSER_SYMMETRIC_FUNCTION_E	Variables are symmetric, this will tell the optimizer that the order of variables is not of interest

Function Documentation

bool Core::ClosestLineToLine	(	double &	s,
		double &	t,
		const Point &	a0,
		const Point &	a1,
		const Point &	b0,
		const Point &	b1,
		const double	epsilon = `1e-12`
	)

Compute s and t such that the distance between a0 + s * (a1 - aO) and b0 + t * (b1 - b0) is minimal. Return false if the lines are parallel, true otherwise.

void Core::ClosestPointOnTriangle	(	Point &	result,
		const Point &	p,
		const Point &	a,
		const Point &	b,
		const Point &	c,
		const double	epsilon = `1e-12`
	)

Compute the point on the triangle closest to the given point. The distance to the triangle will be (P - result).length())

Core::CORE_ENUM_CLASS	(	PythonActionMode	,
		INTERACTIVE_E	,
		BATCH_E	,
		REPLAY_E
	)

Parameters

INTERACTIVE_E	Run actions in interactive mode: actions that require resources not immediately available will fail.
BATCH_E	Run actions in batch mode: actions will wait for resources to become available and retry.
REPLAY_E	Run actions in replay mode: actions won't recorded into the provenance buffer.

Core::CORE_ENUM_CLASS	(	MouseButton	,
		NO_BUTTON_E	= `0x00000000`,
		LEFT_BUTTON_E	= `0x00000001`,
		RIGHT_BUTTON_E	= `0x00000002`,
		MID_BUTTON_E	= `0x00000004`
	)

Enums for mouse buttons they have the same values as corresponding Qt ones Enums for key modifiers they have the same values as corresponding Qt ones

Core::CORE_ENUM_CLASS	(	ActionStatus	,
			SUCCESS_E = `0`,
			ERROR_E = `1`,
			INVALID_E = `2`,
			UNAVAILABLE_E = `3`
	)

This enum lists the possible outcomes of preforming an action.

This enum lists the possible sources of where an action can be triggered from. Depending on the source the action may change. For instance, an action run from the provenance buffer requires a different path for recording provenance.

Parameters

SUCCESS_E	ACTION_SUCCESS - Everything went fine and the action was executed
ERROR_E	ACTION_ERROR - The action did not execute properly and failed
INVALID_E	ACTION_INVALID - The action did not get validated
UNAVAILABLE_E	ACTION_UNAVAILABLE - The action could not be executed, because resources are not available

Core::CORE_ENUM_CLASS	(	IntersectionType	,
		INSIDE_E	= `1`,
		INTERSECT_E	= `0`,
		OUTSIDE_E	= `-1`
	)

Expand the bounding box to include bounding box b

Expand the bounding box to include a disk centered at cen, with normal normal, and radius r.

bool Core::CreateOrIgnoreDirectory ( const boost::filesystem::path & dir_path )

Create the directory if it doesn't exist, otherwise do nothing. Returns true if the directory already exists, or it was created successfully, otherwise false.

double Core::DistanceToLine2	(	const Point &	p,
		const Point &	a,
		const Point &	b,
		const double	epsilon = `1e-12`
	)

Compute the distance squared from the point to the given line, where the line is specified by two end points. This function actually computes the distance to the line segment between the given points and not to the line itself.

void Core::EstimateClosestPointOnQuad	(	Point &	result,
		const Point &	p,
		const Point &	a,
		const Point &	b,
		const Point &	c,
		const Point &	d,
		const double	epsilon = `1e-12`
	)

This is only an estimate for an element that is not flat, it is exact for a flat element.

std::string Core::ExportToString ( DataType data_type )

This class describes the data types that the program uses.

Import a DataType from a string NOTE: If the import fails UNKNOWN_E is returned and the function returns false Export the data type to a string

bool Core::ImportFromString	(	const std::string &	str,
		TransferFunctionControlPointVector &	control_points
	)

Import a vector of control points from string. Returns true on success, otherwise false.

bool Core::ImportFromString	(	const std::string &	str,
		TransferFunctionControlPoint &	control_point
	)

Import a control points from string. Returns true on success, otherwise false.

bool Core::RecursiveCopyDirectory	(	const boost::filesystem::path &	from,
		const boost::filesystem::path &	to
	)

Copy a directory recursively. Returns true on success, otherwise false.

bool Core::ScanCommand	(	const std::string &	str,
		std::string::size_type &	start,
		std::string &	command,
		std::string &	error
	)

Scan for the first command in the string str starting at start the function will return true if it success and other wise returns an error. It returns the next scan point in start

bool Core::ScanKeyValuePair	(	const std::string &	str,
		std::string::size_type &	start,
		std::string &	key,
		std::string &	value,
		std::string &	error
	)

Scan for the first key value pair in the string str starting at start the function will return true if it success and other wise returns an error. It returns the next scan point in start

bool Core::ScanValue	(	const std::string &	str,
		std::string::size_type &	start,
		std::string &	value,
		std::string &	error
	)

Scan for the first value in the string str starting at start the function will return true if it success and other wise returns an error. It returns the next scan point in start

void Core::TerminateEventHandler ( EventHandlerHandle & eventhandlerhandle )

This function terminates the object that uses the eventhandler We need an additional thread to terminate the eventhandler thread safely.

Variable Documentation

const CappingTableType Core::CAPPING_TABLE_C[]

Initial value:

= {
  {{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 0},  
  {{0, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 1},   
  {{4, 1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 1},   
  {{0, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1}, 2},    
  {{6, 5, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 1},   
  {{0, 4, 7, 7, 4, 5, 7, 5, 6, 6, 5, 2}, 4},        
  {{4, 1, 6, 6, 1, 2, -1, -1, -1, -1, -1, -1}, 2},    
  {{0, 6, 7, 0, 1, 6, 6, 1, 2, -1, -1, -1}, 3},     
  {{7, 6, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1}, 1},   
  {{0, 4, 3, 3, 4, 6, -1, -1, -1, -1, -1, -1}, 2},    
  {{7, 6, 3, 7, 4, 6, 4, 5, 6, 4, 1, 5}, 4},        
  {{0, 6, 3, 0, 5, 6, 0, 1, 5, -1, -1, -1}, 3},     
  {{7, 5, 3, 3, 5, 2, -1, -1, -1, -1, -1, -1}, 2},    
  {{0, 5, 3, 0, 4, 5, 3, 5, 2, -1, -1, -1}, 3},     
  {{7, 4, 3, 3, 4, 2, 4, 1, 2, -1, -1, -1}, 3},     
  {{0, 1, 3, 3, 1, 2, -1, -1, -1, -1, -1, -1}, 2}}

Core::COMMANDLINE_E = 6

COMMANDLINE_E - This action is run from the command line, it needs to update the interface, but does not allow queuing

const ullong_float_type Core::inf_value_f

Initial value:

=

{ 0x7ff0000000000000ull }

Core::INTERFACE_KEYBOARD_E = 3

INTERFACE_KEYBOARD_E - The action is run from the interface, but through a keyboard interaction

Core::INTERFACE_MOUSE_E = 2

INTERFACE_MOUSE_E - The action is run from the interface, but through a mouse interaction

Core::INTERFACE_WIDGET_E = 1

INTERFACE_WIDGET_E - The action is run from the interface, the interface may not need an update, if the GUI already did the update.

const ullong_float_type Core::nan_value_f

Initial value:

=

{ 0x7fffffffffffffffull }

Core::PROVENANCE_E = 7

PROVENANCE_E - The action is run from the provenance buffer Hence it should not be recorded again into the provenance buffer

Core::SCRIPT_E = 5

SCRIPT_E -The action is run from a script, which means that the interface needs to be updated and as well that actions need to be queued. Hence for this source the required resource lock needs to be returned, so the script can wait for the action to be completed.

Core::UNDOBUFFER_E

Initial value:

= 8
)
class ActionContext

UNDOBUFFER_E - The action is run from the undo buffer.

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation