Fiber Namespace Reference

Given a fragmented field of curvilinear coordinates, (3D array of coordinates), build a uniform Grid object that contains a list of curvilinear cells per uniform cell. More...

Namespaces
namespace	RegularTopology
	A collection of functions to compute topological properties.

Classes
struct	AcceptType
	A template helper class to provide an easier syntax for allowing certain field types to be accepted by this fish. More...
struct	AcceptType< META::LIST< Type... > >
struct	AcceptType< T >
struct	AccessibleParserContext
struct	AND
	Combining bundle properties as AND operation. More...
struct	ArrayCollector
class	ArrayInterpolator
	A field's interpolator is an interface for this specific field. More...
class	ArrayList
class	ArrayRef
	An array reference class, which is a convenience class for reference pointers to multidimensional memory arrays. More...
class	AsynchronCreator
	A Creator object that generates its content on demand. More...
class	Atlas
	The Grid Atlas contains the set of all charts which are defined on a Grid object. More...
struct	AverageField
class	BaseSpace
	Base class for spaces that may be used for mapping domains to fiber spaces. More...
class	BaseSpaceDependency
	A base class for dependencies on a BaseSpace. More...
struct	bgr
struct	BinaryOperator
	Implementing a binary operation on two fields with on-demand computation per fragment and discarding data when memory is tight. More...
class	Binder
	Base class to allow binding a Fiber Bundle data structure to some storage device, similar to swapping data from in and out of memory. More...
class	BinderBase
	Base class to allow binding a Fiber Bundle data structure to some storage device, similar to swapping data from in and out of memory. More...
class	Bundle
	The main entity holding all information. More...
class	BundleInput
class	BundleLoaderProgress
	Loading progress callback functor. More...
class	BundleProperty
	Convenient abstract base class for inspecting and evaluating properties of Bundles. More...
class	BundlePtr
	Convenience class that implements a pointer to a Bundle object but adds some useful member funtions that lets the pointer resemble the same properties as the Bundle object itself. More...
class	BundleSaver
class	CartesianChart3D
	Chart object for cartesian coordinates. More...
struct	CartesianFragments
class	CatMullRomSpline
	Catmull-Rom cubic spline interpolation. More...
struct	Cell
	A type describing a cell in a cell complex. More...
class	CellCluster
	A set of cells stored on a Grid. More...
struct	CellDirectionsFixed
	Creator for a vector field pointing from the cell centers of the strong neighbors to the center of the cell of interest stored as a vector field in the cells as cells topology. More...
struct	CellDirectionsVariable
	Creator for a vector field pointing from the cell centers of the weak neighbors to the center of the cell of interest stored as a vector field in the cells as cells topology. More...
struct	CellNeighborhoodFixed
	Creator for computing strong neighbors and stores them as a fixed array of cell indices per cells in a cells as cells topology (positions field, 2D Memarray). More...
struct	CellNeighborhoodVariable
	Creator for computing weak neighbors and stores them as a std::vector of cell indices per cells in a cells as cells topology (positions field, vlen). More...
struct	CellSearch
class	Chart
	A generic Chart object that may be used to cast information of points within a manifold to numerical values. More...
class	ChartCreator
class	ChartCreatorBase
class	ChartID
	A Chart ID is just a textual description of the certain chart object; there may be many chart objects which all share the same ChartID. More...
class	ChartIDList
struct	ChartRegistry
struct	CheckType
struct	ChildrenProperties
struct	Collector
struct	Collector< Bundle >
struct	Collector< Grid >
struct	Collector< Skeleton >
struct	Collector< Slice >
struct	CollectVertexFieldStartIndizes
struct	CompareEdges
	CompareEdges Input: Two edges (E0 & E1), each consists of two point indices, eg: 3,4 and 7,3. More...
struct	CompareFragmentIDs
struct	CompareFragmentIDsNumerically
class	ComputationalField
	A field which contains computational operations that are executed on demand per fragment. More...
struct	ComputeBounds
struct	ComputeCellField
struct	ComputePartialDerivative
	Compute the partial derivative of a multidimensional array in the given index direction. More...
struct	ComputePartialDerivative< Dims_t(-1)>
	Stop the recursion of computing the partial derivatives over all dimensions. More...
struct	ComputeRange
	A class to compute the range of fields or field fragments. More...
struct	ComputeUnitVector
struct	ComputeVertexNormals
struct	const_ranged_for_iterator
class	ConstSkeletonIterator
	Base class for constant iterators over a sequence of skeletons. More...
class	CoordinateAxisArray
class	CoordinateAxisArray< T, ExplicitCoordinateAxisArray >
	An implementation of the one-dimensional array that contains monotoneously increasing coordinates for each index. More...
class	CoordinateAxisArray< T, LinearCoordinateAxisArray >
	A one-dimensional linear array, i.e. More...
class	CoordinateAxisArray< T, PolynomialCoordinateAxisArray >
	An implementation of the one-dimensional procedural array that computes its elements as an polynomial expression of the index. More...
struct	CopyMemArrayIterator
struct	CopyMemArraySourceTypeIterator
class	CopySkeletons
	This Skeleton iterator takes a new Grid as an input and copies topological related information to the new Grid. More...
struct	CreateFromLinear
	A helper class to be used for multilinear index construction. More...
struct	CreateTexture
	Template class to load OpenGL textures of a specified type from Memory Arrays. More...
class	CreativeArray
	A helper class that keeps objects in memory all time. More...
class	CreativeArrayBase
	Base class for multidimensional arrays that employ deferred storage, i.e. More...
struct	CreativeArrayBaseContainerBase
	This class will be "injected" into the owning class, which means the Field class will be derived from this one. More...
struct	CreativeFieldResampler
	Base class for resampling n-dimensional fields. More...
class	CreativeIterator
	An iterator with an optional DataCreator, which is just a class to intercept creation of data along a subset. More...
struct	CreativeResampleFragmentIterator
	Strategy: Iterate over the source grid, creating a fragments in the new Grid as specified by the resampling parameters. More...
struct	CreativeResampleUniformCartesian3DIterator
	A resample class specifically for uniform arrays. More...
class	CubicIpol
	Cubic interpolation using Hermite polynoms. More...
struct	CurveDerivative
	An operator for OnDemandCreators to be used on LineSet's. More...
struct	CurvilinearGrid3D
struct	CurvilinearSearch
struct	CurvilinearSearch< Eagle::PhysicalSpace::point >
struct	DataCreator
struct	DataRange
	Class for ranges of types, such as minimum/maximum. More...
struct	DataRangeBase
	Base class for ranges that can be attached to Creators. More...
struct	Derivative
struct	DerivativeOperatorData
struct	DeriveArray
	Compute the partial derivative of a multidimensional array. More...
struct	DeriveArray< Interpol, -1, Delimiter >
struct	DeviatoricRadius
struct	DeviatoricStress
struct	DihedralCell
class	DimensionalInterpolator
	Abstract N-dimensional interpolator class. More...
class	DirectProductMemArray
class	DirectProductMemArrayBase
	Class for creating structured types as direct product of one-dimensional arrays. More...
struct	DirectProductMemArrayCreateBaseArray
struct	DoebyGDAL
struct	DoebyKml
struct	DoebyLas
struct	DoebyTiff
class	DynamicSize
	A class describing an n-dimensional space at runtime. More...
class	EdgeFlipCriterion
class	EdgeLengthCriterion
class	Edges
	Identify the edges on a skeleton within a Grid. More...
struct	EigenArrays
	Contains typed arrays to EigenValues and EigenVectors. More...
struct	EigenFields
struct	EigenIterators
	Contains iterators to eigenvalues and eigenvectors. More...
struct	EigenValueArrays
	Contains typed arrays to EigenValues and EigenVectors. More...
struct	EigenValueIterators
	Contains iterators to eigenvalues. More...
class	EigenVectorFlipper
class	ElementIterator
	An iterator which allows to access each component element type of an array of vectors, or a vector of arrays. More...
class	ElementProxy
	A proxy for Iterators, such that an Iterator's element looks like an Iterator's element (!), even though it isn't (the internal storage layout may be different). More...
struct	ElementryArrayTrait
struct	EuclideanMetric
	A namespace-like class implementing operations that are required from a metric field that implements the Euclidean metric in 3D. More...
struct	EvalExpression
struct	EvalFragment
struct	EvaluateResampleFragmentIterator
class	EvolutionIterator< Field >
class	EvolutionIterator< Grid >
	Callback iterator functor for iterating over the grids of a bundle. More...
class	EvolutionIterator< Skeleton >
	Callback iterator functor for iterating over the grid skeletons of a bundle. More...
class	EvolutionIterator< Slice >
	Iterator for Slices. More...
struct	ExplicitCoordinateAxisArray
struct	ExplodeTensor
struct	ExpRemap
struct	Expression
struct	ExtractSlice
struct	ExtractSlice< Operator, META::LIST< Array3D, NEXT > >
struct	ExtractSlice< Operator, META::NIL >
class	F5Domain
struct	F5Skeleton
	A helper class to create an F5Path from FiberLib context information. More...
class	F5StreamSaver
class	FastCubicIpol
	Fast cubic interpolation which requires the same number of sampling points as the linear interpolation, but provides a smooth derivative at the cost that this derivative is always zero at the samplint points. More...
class	FEM
struct	FEMOperatorData
class	FiberMap
	Base class for fields defined on some base space. More...
class	FiberType
	Description of types, which is meta-information like what is the number of elements of some array-like type. More...
class	FiberTypeBase
	Abstract procedural description of a data element which may be used to construct arrays and fields. More...
struct	FiberTypeIndex
struct	FiberTypeMap
	https://stackoverflow.com/questions/17614172/c-template-singletons-in-a-dll More...
struct	FiberTypeMultiMap
	https://stackoverflow.com/questions/17614172/c-template-singletons-in-a-dll More...
class	Field
	A Field is a collection of CreativeArrayBase reference pointers which are accessed via FragmentID objects. More...
class	FieldCollection
	A collection of arbitrarily named Field references. More...
struct	FieldEvaluator
struct	FieldExplorer
struct	FieldExplorer< MultiArray< Dims, ValueType > >
struct	FieldFragmentSaver
class	FieldID
	Identifier for Fields within a Grid. More...
class	FieldInterpolator
	The FieldInterpolation class provides a function to do data interpolation on a data field. More...
class	FieldInterpolator< FieldType, CoordType, FieldInterpolatorBase::ANALYTIC >
class	FieldInterpolator< FieldType, CoordType, FieldInterpolatorBase::CUBIC >
class	FieldInterpolator< FieldType, CoordType, FieldInterpolatorBase::LINEAR >
class	FieldInterpolator< FieldType, CoordType, FieldInterpolatorBase::RECTILINEAR >
class	FieldInterpolator< tvector, CoordType, FieldInterpolatorBase::EIGENCUBIC >
class	FieldInterpolator< tvector, CoordType, FieldInterpolatorBase::EIGENLINEAR >
class	FieldInterpolatorBase
class	FieldIterator
	Class for iterating over fields, in particular those contained in a Representation object. More...
struct	FieldProxy
	A proxy object that looks like a RefPtr<Field> but equips fields with a FieldCreator and a FragmentIDCollection on assignment. More...
class	FieldRef
	Context information for creating a field and inserting data. More...
struct	FieldSaver
class	FieldSelection
	An abstract selection of fields, that is given by names of fields and possible types for each field. More...
class	FieldSelector
	An internal class that stores a couple of textual names. More...
struct	FiniteDifferenceTrait
	Type trait class to assign the partial derivative of some difference type to some result type. More...
struct	FiniteDifferenceTrait< double >
	Special case of assigning partial derivatives of a scalar field to a one-dimensional result type, i.e. More...
struct	FishStorageTransformations
	A base class with some heuristic default settings. More...
class	FixedArrayTrait
class	FixedArrayTrait< T, 1 >
class	FlatMap
class	Fragment
	Data structure describing all fields available per fragment, which is a selection of createable data arrays. More...
class	FragmentCluster
	A collection of field fragments, as retrieved by a FieldCollection, and possibly stored over many refinement levels. More...
struct	FragmentCoordinates
struct	FragmentedSizeInterface
struct	FragmentedUniformGrid3D
struct	FragmentedUniformGrid3DPoints
struct	FragmentFunctor
class	FragmentID
	Identification information about a field's fragment. More...
class	FragmentIDCollection
	A collection of fragment identifiers with bijective mapping to an integer fragment number. More...
class	FragmentIDCollectionProvider
	Convenience base class. More...
class	FragmentIDContainer
class	FragmentIndexIterator
struct	FragmentIsoSurfacer
class	FragmentIterator
	Base class for iterators over the fragments of a field. More...
class	FragmentLocation
struct	FragmentMetaIndirector
	An interface on creators for fragments in relative representations, used within function Skeleton::createIndirectedField() to provide meta information for a newly created Creator. More...
struct	FragmentSearch
struct	FragmentSearchBase
class	FragmentSelector
	Abstract base class to select a certain subset from a Field's collection of fragments. More...
struct	FragmentSkeleton
	Fragment Skeleton: Each fragment of a field is assigned some value in the form of a field defined on the fragment skeleton. More...
struct	FragmentSlicer
	Extract 2D slices from a regular 3D data field along a given coordinate. More...
struct	FragmentTopology
struct	FS
struct	fsFieldFragmentSaver
struct	fsFieldSaver
struct	FSFieldSaverInit
struct	FSFieldSaverStorageIterator
struct	fsGridSaver
class	FSLoader
class	FSLoader< Bundle >
struct	fsRepresentationSaver
class	FSSaver
class	FSSaver< Bundle >
class	FSSaver< MemArrayBase >
class	FSSaver< MemArrayStorage< N, T, Storage > >
class	FSSaver< MemArrayStorage< N, T, vector< T > > >
class	FSSaverCreator
class	FSSaverCreator< Bundle >
class	FSSaverCreator< MemArrayStorage< N, T, Storage > >
struct	fsSkeletonSaver
struct	fsSliceSaver
class	FunctionalCreator
class	FunctionalCreatorBase
struct	GammaRemap
struct	GDALGlobals
	A data structure to bundle all global static variables into one object with precisely defined construction/destruction order. More...
struct	GDALSaver
struct	GetFragmentRange
class	GlobalCharts
	A list of chart identifiers (i.e. More...
class	Grid
	A Grid is a set of Skeleton objects, each of them accessed via some unique SkeletonID object. More...
class	GridContainer
	An abstract base class for a list of Grid objects. More...
struct	GridEvaluator
	Helper class for evaluating Fields given in one Grid on another Grid, used by EvalGrid(). More...
struct	GridField
	A helper class to retrieve fields given on a Grid. More...
class	GridID
	A grid identifier. More...
struct	GridInspector
class	GridIterator
	Iterator callback object for iteration within time slices. More...
class	GridList
	A sequence of Grid objects with identifiers. More...
class	GridLoader
class	GridProperty
	An abstract bundle property which returns true if a Grid with the property query as implemented in this subclass will return true. More...
struct	GridSaveParameters
struct	GridSaver
class	GridSelector
	Context information to select a grid from within a bundle. More...
struct	GridWithCartesianVertices
struct	H5Globals
	A data structure to bundle all global static variables into one object with precisely defined construction/destruction order. More...
class	H5ID
	A database for mapping HDF5 Type ID's to and from FiberType's. More...
class	H5NativeTypeID
class	hasCartesianCoordinates
	Checks if the given Grid has a representation in cartesian coordinates. More...
class	hasExplicitCartesianCoordinates
	Checks if the given Grid has a explicit cartesian coordinates, i.e, no procedural coordinates such as a direct product. More...
class	hasSkeletonOfGridType
struct	HDF5
struct	HDF5Binder
class	HDF5BindingIndicator
class	HDF5Creator
	Deferred creation of MemBase objects from an HDF5 file. More...
class	HDF5CreatorBase
	Deferred creation of MemBase objects from an HDF5 file. More...
struct	HDF5DimensionalFieldSaverStorageIterator
struct	HDF5DimensionalFieldSaverStorageIterator< Type, 1 >
struct	HDF5FieldSaverInit
struct	HDF5FieldSaverStorageIterator
class	HDF5Loader
class	HDF5Loader< Bundle >
	Loader implementation for Bundle objects via HDF5. More...
struct	HDF5LoaderRequest
struct	HDF5LoadList
class	HDF5Producer
	Deferred creation of MemBase objects from an HDF5 file. More...
struct	HDF5Saver< Chart >
class	HDF5SaverCreator
class	HDF5SaverCreator< MemArrayStorage< N, T, Storage > >
class	HDF5stringCreator
	Deferred creation of MemBase objects that contain vectors of data per element from an HDF5 file. More...
struct	HDF5TypeAction
	Convenience class that registers some HDF5 type ID for an intrinsic C++ type. More...
class	HDF5VLenCreator
	Deferred creation of MemBase objects that contain vectors of data per element from an HDF5 file. More...
struct	HilbertFragmentVertexSearch
class	HyperslabParameters
	A set of integer values which describes how to iterate over a certain set of values. More...
struct	IdentityOperator
struct	IJ_CellNamingConvention
	A naming convention for cell components using "i" and "j". More...
struct	ImageSequence
struct	ImageSequenceLoader
struct	IndexListViaSelectionString
struct	IndexTypeConfig
struct	IndexTypeConfig< 4 >
struct	IndexTypeConfig< 8 >
struct	Info
	Generic template namespace class for results of find() functions throughout the Bundle. More...
struct	Info< Grid >
	The information as returned by a query for Grids. More...
struct	Info< Representation >
	The information as returned by a query for Representations. More...
struct	Info< Skeleton >
	The information as returned by a query for Skeletons. More...
struct	Info< Slice >
	The information as returned by a query for Slices. More...
struct	IntegrationPointVertices
struct	Interpolate
	The interpolator template. More...
struct	Interpolate< 1, Type, Interpol, CoordinateType, Delimiter, DerivativeDimension >
	One-dimensional interpolation, basically a wrapper for the Interpol argument. More...
struct	Interpolate< 2, Type, Interpol, CoordinateType, Delimiter, DerivativeDimension >
	Two-dimensional interpolation. More...
struct	Invariant1
struct	Invariant2
struct	Invariant3
class	IpolDerivative
	Internal intermediate template which computes a one-dimensionally interpolated value, and optionally its derivative. More...
class	IpolDerivative< T, Interpol1D, true >
	Internal intermediate template which computes a one-dimensional interpolation of a derivation. More...
class	isCurvilinearGrid
	Checks if the given Grid is a Curvilinear Grid. More...
class	isFragmentedUniformCartesianGrid
	Checks if the given Grid is uniform in cartesian coordinates, possibly in multiple fragments. More...
struct	IsoException
class	isRegularGrid
	Checks if the given Grid is regular. More...
struct	IsSimpleType
struct	IsSimpleType< false >
struct	IsSimpleType< true >
class	isUniformCartesianGrid
	Checks if the given Grid is uniform in cartesian coordinates. More...
class	Iterator
	Implementation of an Iterator to a sequence of elements, which might be contiguous or a projection of a component from an array of vectors. More...
class	Iterator< Eagle::FixedArray< T, C > >
	Implementation of the Separated Compound field type that may virtually merge many separate arrays as one. More...
class	Iterator< Field >
class	Iterator< FragmentID >
class	Iterator< Grid >
class	Iterator< Representation >
class	Iterator< Skeleton >
class	Iterator< SkeletonID >
class	Iterator< Slice >
class	IteratorBase
	Intermediate base class for generic iterators. More...
struct	KDTreeCloudSearch
struct	KDTreeCloudSearch< PointType, VertexWeights >
struct	KmlGlobals
	A data structure to bundle all global static variables into one object with precisely defined construction/destruction order. More...
struct	KmlSaver
struct	LasGlobals
	A data structure to bundle all global static variables into one object with precisely defined construction/destruction order. More...
struct	LasSaver
struct	Leaflet
class	LeaftletCreator
	http://b.tile.openstreetmap.org/0/0/0.png More...
struct	LinearCoordinateAxisArray
class	LinearDirectProductMemArray
	Convenience class - a Direct Product array which uses linear expressions for each index dimension. More...
class	LinearIpol
	Linear interpolation. More...
class	LinearIpol< T, true >
	An alternative version of the linear interpolator that works for types which do not allow scalar multiplication, such as points in a space. More...
struct	LinearIpolZeroDerivativeTrait
	Helper class (type trait) for class LinerIpol, which for a given type T provides a static member function zero() returning the value for out-of-bound derivatives. More...
struct	LinearIpolZeroDerivativeTrait< metric33 >
struct	LinearIpolZeroDerivativeTrait< metric44 >
class	LineSet
	A set of lines stored on a Grid. More...
class	LineSetWithEdges
class	LoaderControl
struct	LoadQueue
struct	LoadTexture
class	LocalFromWorldPoint
	Use this class to compute a local cell index and fragment ID (if neccessary) of any coordinate field on a given slice and grid. More...
struct	LocalPoint
class	MDHistory
	A convenience grid type for molecules. More...
struct	MeanStress
class	MemArray
	Class for N-dimensional MultiArrays with MemCore memory management. More...
class	MemArrayAllocator
	Allocating array types through registry of types. More...
class	MemArrayBase
	Abstract class for N-dimensional MultiArrays with MemCore memory management. More...
class	MemArrayGetSlice
class	MemArrayGetSlice< 1 >
class	MemArrayProperties
	Interface class to provide information about multidimensional arrays without need to create the data itself. More...
class	MemBase
	Base class for multidimensional arrays with MemCore memory management. More...
struct	MExpression
struct	Mises
class	MultiArray
class	MultiArray< 0, T >
class	MultiArray< N, T, std::index_sequence< Is... > >
	A multidimensional array for data that are stored via a native, writable C++ pointer. More...
class	MultiArrayBase
	A generic multidimensional array is a one-dimensional pointer together with a specification of the extent in some dimensions. More...
class	MultiArrayBase< 1, T >
	Stop the recursive definition of multidimensional arrays. More...
struct	MultiArrayOutStreamSeparator
struct	MultiArrayOutStreamSeparator< 1 >
struct	MultiArrayOutStreamSeparator< 2 >
struct	MultiArrayOutStreamSeparator< 3 >
struct	MultiArraySTLVector
	A multidimensional array for data that are stored in an STL vector<>. More...
class	MultiIndex
	A recursively defined multidimensional index. More...
class	MultiIndex< 1 >
	Stop multidimensional indexing recursion. More...
struct	MultiIndexIterator
class	MultiOp
class	MultiOp< 1, MultidimensionalOperator, 1 >
class	MultiOp< 1, MultidimensionalOperator, SkipDims >
class	MultiOp< Dims, MultidimensionalOperator, Dims >
class	MultiOperate
	Template class for multidimensional operations. More...
struct	myData
struct	myHDF5Loader
class	MySaverCreator
struct	NamedField
struct	NanoFlannPointCloudAdaptor
	Adaptor for interfacing the nanoflann library. More...
class	NearestNeighborIpol
	Nearest-Neighbor interpolation, just fast and wrong. More...
class	NoDelimiter
struct	NOT
	Inverting a bundle property. More...
struct	NotDoebyShapefile
class	Occurrence
	A template family to collect information where certain objects reside within a Bundle. More...
class	Occurrence< Bundle >
class	Occurrence< Grid >
class	Occurrence< Representation >
class	Occurrence< Skeleton >
class	Occurrence< Slice >
struct	OccurrenceMap
class	OnDemandCreator
	A Creator object that allows to create data on demand, when they are used and accessed. More...
struct	OR
	Combining bundle properties as OR operation. More...
class	Ownable
	Domain-specific class of objects that can be owned. More...
class	OwnerBase
	Base class for objects that are owned by others and owning others. More...
class	Parameter
class	ParameterID
class	ParameterList
class	ParameterSet
class	ParameterSpace
struct	PartialDerivator
struct	PartialDerivatorBase
struct	PlainCopyConvert
struct	PNGError
struct	PointSearch
	Point Search Utility functions for finding points in a grid based on provided coordinate information. More...
struct	PolynomialCoordinateAxisArray
struct	Power2Alignment
struct	Range_as_FloatVersion
	Type trait class to help DataRange<T> . More...
struct	ranged_for_iterator
struct	ranged_for_iterator< Eagle::FixedArray< T, C > >
struct	RangedFloatSlicer
	Extract a 2D slice of floating point data from a 3D grid and perform data rescaling using a linear range. More...
struct	RangeException
struct	RangeFailureAction
struct	RangeFailureAction< 0 >
struct	RangeFailureAction< 1 >
struct	RangeFailureAction< 2 >
struct	RangeFailureAction< 3 >
class	RawData
	Call unpackAs() in the Creator's create() function if the actual data type stored does not match the desired output type as specified via a TypeID. More...
class	RawFileCreator
class	RawImageBufferCreator
	https://www.libraw.org/docs More...
class	RawImageCreator
	There is one common RawImageBufferCreator for many RawImageCreator. More...
class	ReferencingMemArray
	A memory array that may share its data storage with something else. More...
class	RefinedFragmentSkeleton
	A relative representation from the fragments of one one Skeleton to the fragments of another Skeleton. More...
struct	RegularCell
	A type describing an n-dimensional regular cell. More...
struct	RegularCell< 0, IndexType, NamingConvention >
struct	RegularCoordinateSlice
	Helper class to select a slice from a regular grid. More...
struct	RegularFragmentTopology
struct	RegularGrid3D
struct	RegularlyFragmentedClusteredPointCloudGrid
	Grid type for a fragmented point cloud proving a cell look into presorted vertices. More...
struct	RegularlyFragmentedCurvilinearGrid3D
class	RegularlyFragmentedField
	A convenience class for optimized handling of fields that are fragmented in a regular manner (n-dimensional tiling). More...
struct	RegularlyFragmentedGrid
struct	RegularlyFragmentedGridBase
struct	RegularlyFragmentedGridWithCartesianVertices
struct	RelativeRepresentation
	A relative representation from one Skeleton to another Skeleton where elements of one Skeleton are related to the other one. More...
struct	RelativeToBinder
struct	Remap
class	Representation
	A Representation is a set of Field objects, each of them accessed via some FieldID identifier. More...
class	RepresentationMap
	A map that associates Representer objects with Representation instances. More...
struct	RepresentationSaver
struct	ResampleArray
class	RGBAChart
	Chart object for RGBA coordinates. More...
class	RGBOperator
struct	SampleParameters
class	SaveableAttributes
	Attributes with an age that allows to keep track when the attributes had been saved last. More...
struct	SaveImage
class	SaveItem
	An interface object to signal a processOwner() function that some data item should be saved. More...
class	ScalarMultiHistogram
	Convenience class to operate with a set of histograms. More...
struct	SearchFragmentVertex
struct	SelectionExtractor
	fragment iterator to extract a selection (fragment) from a field More...
struct	setDimensions
struct	ShapefileGlobals
	A data structure to bundle all global static variables into one object with precisely defined construction/destruction order. More...
struct	ShapefileSaver
struct	SimplexCell
	A type describing an n-dimensional simplex cell. More...
struct	SimplexCell< 0, IndexType >
struct	SingleFragmentCompute
class	SizeInterface
	An interface telling size and dimensionality of a dataset, a refcounted version of DynamicSize. More...
struct	SizeOf
class	Skeleton
	A Skeleton is a set of Representation object, each of them accessed by an Representer object. More...
class	SkeletonExistence
	A concrete Grid Property which looks for the existence of a Skeleton of the specified dimension and index depth. More...
class	SkeletonID
	Identifier for Skeletons within a Grid. More...
class	SkeletonIterator
	Base class for iterators over a sequence of skeletons. More...
class	SkeletonMap
	A Skeleton Map is a unique map from SkeletonID's to Skeletons. More...
struct	SkeletonPtrEqual
struct	SkeletonPtrHash
struct	SkeletonSaver
class	Slice
	Information per time slice, mainly a set of Grid objects that are accessed via GridID objects. More...
struct	SliceConstructor
	Helper class for slice constructors. More...
struct	SliceExtractor
	Template class to construct an OnDemandCreator to extract a 2D slice from a 3D data array with abitrary data conversion during extraction. More...
struct	SliceExtractor< Converter, META::LIST< InputType, NextType > >
	The slice extractor for a list of input types. More...
struct	SliceExtractor< Converter, META::NIL >
	Base class of all SliceExtractors. More...
class	SliceMap
	An helper class for a collection of slices. More...
class	SlicePtr
	Convenience shortcut for pointers to Slices. More...
struct	Slicer
	Helper class to select a slice from a regular grid. More...
struct	SlicerBase
	Helper class to select a slice from a regular grid. More...
struct	SliceSaver
class	SplitAllCriterion
class	StorageTransformations
struct	StressTensorArrays
	Contains typed arrays to StressTensorValues. More...
struct	StressTensorFields
struct	StressTensorValueArrays
	Contains typed arrays for stress tensor realted values. More...
struct	StressTensorValueIterators
	Contains iterators to eigenvalues. More...
class	SurfaceRefinementCriterion
struct	TangentialDifferentialEquationAnalytic
struct	TangentialVectorsAndCurveParameter
	Tangential vectors along a set of lines and the lengths of the lines. More...
class	Tensortype
class	TextureChart
class	TextureChart< 2 >
	Chart object for 2D texture coordinates. More...
struct	TiffGlobals
	A data structure to bundle all global static variables into one object with precisely defined construction/destruction order. More...
struct	TiffSaver
class	TimePolar2DChart
	Chart object for cartesian coordinates. More...
class	Timestep
	Interface class that allows optionally storing integer numbers with a grid as a consecutive timestep information. More...
class	Transformation
	Transformation objects that provide chart transformations, particularily for coordinates, but also other vectorial, tensorial or geometric types. More...
class	Transformator
	Callback interface to allow interfacing a full transformation pipeline provided by external means, e.g. More...
struct	TriangleEdge
class	TriangleSet
	A set of triangles stored on a Grid. More...
struct	TriangularSurface
	A triangular surface stored on a Grid. More...
class	TriangularSurfaceWithEdges
	A triangular surface stored on a Grid, containing vertices, edges, triangles. More...
class	TypedArray
	An intermediate class that allows to operate on the pure type information of some memory array. More...
class	TypedAsynchronCreator
struct	TypedGrid
	Base class for grid types. More...
struct	TypedHDF5VLenCreator
class	TypedIterator
struct	TypeList
	A set of types. More...
union	uDihedral
union	uEdge
	Convenience union to allow member names on edges. More...
union	uHexaHedron
	Convenience union to allow member names on hexahedrons. More...
struct	UnaryOperator
	Implementing an unary operation on a fields with on-demand computation per fragment and discarding data when memory is tight. More...
class	UniformCartesianArray
	Convenience class for procedural linear arrays in cartesian coordinates. More...
struct	UniformFragmentVertexSearch
struct	UniformGrid3D
struct	UniformLookupBuilder
union	uQuad
	Convenience union to allow member names on quads. More...
union	uTetrahedron
	Convenience union to allow member names on tetrahedrons. More...
union	uTriangle
	Convenience union to allow member names on triangles. More...
struct	ValueConvert
struct	VecPacked
struct	VecPacked_10_11_11
struct	VectorRegistry
struct	VertexCellNeighborhood
struct	VertexCluster
class	VertexSelection
	Class representing a vertex selection. More...
struct	VertexSelectionComp
struct	VertexSelectionIterator
struct	VertexWeights
struct	VObjectSystemExecutor
struct	WestinShapeFactors
struct	XML
struct	XMLFieldSaverInit
struct	XMLFieldSaverStorageIterator
class	XMLLoader
class	XMLLoader< Bundle >
class	XMLSaver
class	XMLSaver< Bundle >
class	XMLSaver< MemArrayBase >
class	XMLSaver< MemArrayStorage< N, T, Storage > >
class	XMLSaver< MemArrayStorage< N, T, vector< T > > >
class	XMLSaverCreator
class	XMLSaverCreator< Bundle >
class	XMLSaverCreator< MemArrayStorage< N, T, Storage > >

Typedefs
using	getSkeletonFieldsResults_t = map< string, RefPtr< Field > >
typedef FragmentCoordinates< Eagle::PhysicalSpace::point >	CartesianFragmentCoordinates
typedef std::list< WeakPtr< PartialDerivatorBase > >	PartialDerivatorRegistry_t
typedef Eagle::PhysicalSpace::tvector	tvector
typedef Eagle::PhysicalSpace::point	point
typedef std::pair< RefPtr< MemArray< 1, ::Eagle::PhysicalSpace::point > >, RefPtr< MemArray< 1, TriangleCell > > >	TriangleSurface_t
using	nanoflannKDTree = nanoflann::KDTreeSingleIndexAdaptor< nanoflann::L2_Simple_Adaptor< double, NanoFlannPointCloudAdaptor >, NanoFlannPointCloudAdaptor, 3 >
	Interface to the Nanoflann library: https://github.com/jlblancoc/nanoflann.
template<class FragmentContext >
using	RefinementAllowanceFunction = std::function< std::tuple< bool, FragmentContext >(const RefPtr< Skeleton > &, const RefPtr< FragmentID > &)>
template<class FragmentContext , class RecursionCriterium >
using	RefinementContinuationFunction = std::function< std::tuple< bool, RecursionCriterium >(const FragmentContext &, const RefPtr< FragmentID > &)>
template<class RecursionCriterium >
using	RefinementFragmentEmitFunction = std::function< bool(const RecursionCriterium &TerminalCriteria, const RefPtr< FragmentID > &)>
typedef MemCore::RefPtr< SurfaceRefinementCriterion, SurfaceRefinementCriterion >	VSurfaceRefinementCriterion
typedef LinearDirectProductMemArray< point3 >	ProcArray_t
using	MapToUniformIndexResult_t = std::pair< RefPtr< MemArray< 3, double > >, RefPtr< Chunk< index_t > > >
typedef DomainVector< Vector< color8_t, 3 >, RGB >	rgb_t
typedef LIST< float, LIST< double, LIST< long double, LIST< tvector, LIST< rgb_t > > > > >	BigTypeList
typedef Fiber::MultiIndex< 2 >	VertexSelection_t
using	RefPtrStorageTransformations = RefPtr< StorageTransformations, MemCore::InterfaceBase >
using	hasSkeleton = SkeletonExistence
	Alias name.
typedef MemCore::WeakPtr< Slice, OwnerOf< Grid >::reference_domain_t >	WeakPtrSlice
	Weak pointer to a Slice.
typedef MemCore::RefPtr< Slice, OwnerOf< Grid >::reference_domain_t >	RefPtrSlice
typedef Cartesian4Dd::Point_t	CartesianPt
typedef Cartesian4Dd::Vector_t	CartesianVec
typedef MemArray< 3, rgb16 >	Image16_t
typedef MemArray< 3, rgb >	Image_t
using	SelectionContainer_t = std::vector< myData >
using	AgeRelativeToBinder = RelativeToBinder< MemCore::Ageable >
template<class T >
using	ListRelativeToBinder = RelativeToBinder< std::list< T > >
typedef SimplexCell< 1, uint32_t >	EdgeCell32
typedef SimplexCell< 2, uint32_t >	TriangleCell32
typedef SimplexCell< 3, uint32_t >	TetrahedronCell32
typedef RegularCell< 2, uint32_t >	QuadCell32
typedef RegularCell< 3, uint32_t >	HexahedronCell32
typedef SimplexCell< 1, uint64_t >	EdgeCell64
typedef SimplexCell< 2, uint64_t >	TriangleCell64
typedef SimplexCell< 3, uint64_t >	TetrahedronCell64
typedef RegularCell< 2, uint64_t >	QuadCell64
typedef RegularCell< 3, uint64_t >	HexahedronCell64
typedef EdgeCell32	EdgeCell
typedef TriangleCell32	TriangleCell
typedef TetrahedronCell32	TetrahedronCell
typedef QuadCell32	QuadCell
typedef HexahedronCell32	HexahedronCell
typedef SimplexCell< 1, uint32_t >	EdgeCell32_t
	An edge, consisting of three 32-bit integers.
typedef SimplexCell< 2, uint32_t >	TriangleCell32_t
	A triangle, consisting of three 32-bit integers.
typedef SimplexCell< 3, uint32_t >	TetrahedronCell32_t
	A tetrahedron, consisting of three 32-bit integers.
typedef RegularCell< 2, uint32_t >	QuadCell32_t
typedef RegularCell< 3, uint32_t >	HexahedronCell32_t
typedef SimplexCell< 1, uint64_t >	EdgeCell64_t
typedef SimplexCell< 2, uint64_t >	TriangleCell64_t
typedef SimplexCell< 3, uint64_t >	TetrahedronCell64_t
typedef RegularCell< 2, uint64_t >	QuadCell64_t
typedef RegularCell< 3, uint64_t >	HexahedronCell64_t
typedef DihedralCell< uint32_t >	Dihedral32_t
typedef DihedralCell< uint64_t >	Dihedral64_t
typedef EdgeCell32_t	EdgeCell_t
typedef TriangleCell32_t	TriangleCell_t
typedef TetrahedronCell32_t	TetrahedronCell_t
typedef QuadCell32_t	QuadCell_t
typedef HexahedronCell32_t	HexahedronCell_t
typedef Dihedral32_t	Dihedral_t
typedef Eagle::rgb_t	rgb
typedef Eagle::rgba_t	rgba
typedef Eagle::rgb16_t	rgb16
typedef Eagle::rgb_float_t	rgb_real
typedef Eagle::rgba_float_t	rgba_real
using	RGBColorTypes = LIST< rgb16_t, rgb_t >
using	RGBAColorTypes = LIST< rgba16_t, rgba_t >
using	IntegerHDRColorTypes = LIST< rgba16_t, rgb16_t >
using	HDRColorTypes = LIST< rgb_float_t, rgba_float_t, rgba16_t, rgb16_t >
using	IntegerColorTypes = LIST< rgb16_t, rgba16_t, rgba_t, rgb_t >
using	ColorTypes = LIST< rgb_float_t, rgba_float_t, rgb16_t, rgba16_t, rgba_t, rgb_t >
using	IntegerPixelTypes = LIST< rgb16_t, rgba16_t, rgba_t, rgb_t, unsigned char, unsigned short >
using	PixelTypes = LIST< rgb16_t, rgba16_t, rgba_t, rgb_t, unsigned char, unsigned short, rgb_float_t, rgba_float_t, float >
using	FloatPixelTypes = LIST< rgb_float_t, rgba_float_t, float >
typedef LinearDirectProductMemArray< Eagle::Vector< float,2 > >	UniformVec2fArray
typedef LinearDirectProductMemArray< Eagle::Vector< double, 3 > >	UniformVec3dArray
typedef DirectProductMemArray< Eagle::point3, ExplicitCoordinateAxisArray >	RectilinearCartesianArray
	Rectilinear coordinates.
typedef RectilinearCartesianArray	CartesianRectilinearArray3D
typedef TypeList	TypeList_t
using	fragment_copy_t = std::vector< Field::fragments_t::value_type >
using	FieldFragment = std::pair< RefPtr< Field >, RefPtr< FragmentID > >
using	FieldFragmentRef = std::pair< Field &, RefPtr< FragmentID > >
typedef std::map< string, RefPtr< CreativeArrayBase > >	FragmentMap_t
	Mapping of arbitary names to field fragments.
typedef map< string, RefPtr< Field > >	FieldMap_t
	Mapping of names to fields.
typedef WeakPtr< FragmentIDCollection, FragmentIDCollection >	FragmentIDCollectionWeakPtr
using	FragmentIndex_t = unsigned
typedef FragmentIterator	FieldFragmentIterator
typedef MemCore::WeakPtr< CreativeArrayBase, MemCore::Creature >	WeakPtrCreativeArrayBase_t
template<class OwnedObjectType , class ContainerBase = ChildrenProperties>
using	OwnerOf = typename Ownable< OwnedObjectType, ContainerBase >::Container
	Shortcut to find the owning type.
using	DataSaveItem = SaveItem< RefPtr< MemBase > >
using	CreatorSaveItem = SaveItem< RefPtr< CreativeArrayBase > >
using	BinderInfoItem = OwnerBase::Item< RefPtr< BinderBase > >
typedef typemap< WeakPtr< ChartCreatorBase > >	ChartCreatorRegistry_t
typedef WeakPtr< Chart, BaseSpace::reference_domain_t >	ChartPtr
	A weak pointer to a chart.
typedef RefPtr< Chart, BaseSpace::reference_domain_t >	ChartRefPtr
typedef RefPtr< ChartID >	ChartIdentifier
typedef std::pair< SkeletonID, RefPtr< Skeleton > >	SkeletonInfo
typedef WeakPtr< BaseSpace >	Representer
	The type used to reference other objects, which is the anchor of representations of a Skeleton.
typedef WeakPtr< Representation, typename BaseSpaceDependency::reference_domain_t >	WeakPtrRepresentation_t
typedef RefPtr< Representation, typename BaseSpaceDependency::reference_domain_t >	RefPtrRepresentation_t
using	RepresentationReference = std::tuple< RefPtr< Skeleton >, Representer >
using	CoordinateRepresentationReference = std::tuple< RefPtr< Fiber::Skeleton >, RefPtr< Fiber::Chart > >
using	RelativeRepresentationReference = std::tuple< RefPtr< Fiber::Skeleton >, RefPtr< Fiber::Skeleton > >
using	Topology = Skeleton
typedef uint32_t	FEMIndex_t
typedef std::vector< FEMIndex_t >	FEMIndices_t
typedef std::vector< Eagle::PhysicalSpace::tvector >	FEMDirections_t
typedef std::vector< std::vector< FEMIndex_t > >	FEMFaceList_t
using	FragmentSkeleton = FragmentTopology
typedef uint32_t	vc_index_t
typedef OnDemandCreator< ComputeVertexNormals >	ComputeVertexNormalsOnDemandCreator
typedef map< EdgeCell_t, index_t, CompareEdges >	EdgeMap_t
typedef DirectProductMemArrayBase< Eagle::FixedArray< double, 3 >, LinearCoordinateAxisArray, 3 >	fda
typedef IndexTypeConfig< sizeof(void *)>::index_t	index_t
	Define the index type as according to the size of a pointer, i.e.
typedef Eagle::Mult	Mult
typedef Eagle::Div	Div
typedef Eagle::Add	Add
typedef Eagle::Sub	Sub
typedef RangeFailureAction< FIBER_VECTOR_RANGE_FAILURE_ACTION >	DefaultRangeFailureAction
using	Dims_t = int
typedef MemArray< 3, Eagle::tvector3 >	VectorArray_t
using	ConstString = const char *
typedef Traum::dop853< TangentialDifferentialEquationAnalytic >	LineIntegratorAnalytic

Enumerations
enum	DataCreationMode { AlwaysCreate = 0 , ComputeOrRequest = 1 , ComputeOnlyIfAvailable = 2 }
	Under which conditions to create data when calling ExpandBBox(). More...
enum class	FragmentProperty { Undefined = 0 , Offset = 1 , OverlapStart = 2 , OverlapEnd = 3 }
	Predefined multidimensional properties on fragments.
enum	{ FEM_VERTS =0 , FEM_CELLS }

Functions
RefPtr< Field >	ExecuteExpression (Representation &R, istream &inputstream)
RefPtr< Representation >	GetUniqueCartesianRepresentation (const RefPtr< Grid > &grid)
MemCore::RefPtr< Field >	GetCartesianPositions (MemCore::RefPtr< Grid > grid)
	Extract a Field with skeleton(0,0) and Cartesian3D coordinates named "Position" from the base space from a given grid.
MemCore::RefPtr< Field >	GetFragments (MemCore::RefPtr< Grid > grid)
	Extract the field containing the names of all fields from given grid.
MemCore::RefPtr< Field >	GetFragmentsBBs (MemCore::RefPtr< Grid > grid)
	Extract the field containing the Bounding Boxes of the fragments of a given grid.
MemCore::RefPtr< Field >	GetUniGridMappers (MemCore::RefPtr< Slice > slice, MemCore::RefPtr< Grid > source_grid)
	Extract the fragmented field storing the UniGridMappers.
RefPtr< Field >	createColorFieldOnPoints (const RefPtr< Grid > &grid, const string fieldname)
RefPtr< Field >	getColorFieldOnPoints (const RefPtr< Grid > &grid, const string fieldname)
RefPtr< Field >	EvalGrid (Grid &DestGrid, Grid &SourceGrid, const string &fieldname, Slice &DestGridSlice, const string &HelperDestGridName, bool StoreResult)
	Example: SourceGrid ....
RefPtr< Field >	EvalFieldOnRepresentation (Representation &DstRep, const RefPtr< Skeleton > &DestVertices, Grid &SourceGrid, const string &fieldname, Slice &DestGridSlice, const string &HelperDestGridName, bool StoreResult=true)
	Evaluate a Field given on some source Grid on a specific Representation.
getSkeletonFieldsResults_t	getSkeletonFields (const RefPtr< Fiber::Skeleton > &DestVertexSkeleton, const RefPtr< Fiber::Chart > &chart, const FieldSelector &FS, const string &ImplicitFieldName)
RefPtr< BoundingBox >	ComputeBBox (const RefPtr< MemBase > &CoordBase)
	Compute the bounding box from a given mem array of coordinates.
bool	ExpandBBox (RefPtr< BoundingBox > &BBox, CreativeArrayBase &CAB, DataCreationMode theDataCreationMode=AlwaysCreate)
	Expand a given bounding box by the given data array.
RefPtr< BoundingBox >	getFragmentBBox (const RefPtr< FragmentID > &fid, const RefPtr< CreativeArrayBase > &FragmentDataCreator, const Field &Coords)
RefPtr< BoundingBox >	getBoundingBox (Field &Coords)
RefPtr< BoundingBox >	getBoundingBox (const RefPtr< Field > &Coords)
RefPtr< BoundingBox >	getBoundingBox (const RefPtr< Representation > &Vertices)
RefPtr< BoundingBox >	getBoundingBox (const RefPtr< Skeleton > &Vertices, const RefPtr< Fiber::Chart > &chart)
RefPtr< BoundingBox >	getBoundingBox (const Grid &G, const RefPtr< Fiber::Chart > &chart)
template<int N>
RefPtr< BoundingBox >	getBoundingBox (const RefPtr< RegularlyFragmentedField< N > > &Coords)
RefPtr< Grid >	ExtractTrajectories (Bundle &B, const string &SelectedGridName, double StartTime, double ComaLength, const string &TrajectoryGridName, bool IterateOnlyLoadedSlices)
fiberbaseopQ_API Eagle::PhysicalSpace::bivector	TriangularSurface__NormalVector (const TriangleCell &T, const MultiArray< 1, Eagle::PhysicalSpace::point > &Vertices)
fiberbaseopQ_API RefPtr< MemArray< 1, TriangleCell > >	ConvexHull (const RefPtr< MemArray< 1, Eagle::PhysicalSpace::point > > &InputVertices, const double edge2D_max)
TriangularSurface	GenerateTriangularSurfaceFromPoints (Grid &OutputGrid, const RefPtr< MemArray< 1, point > > &InputVertices, const double EdgeMax)
fiberbaseopQ_API TriangularSurface	GenerateTriangularSurfaceFromPoints (Grid &OutputGrid, const RefPtr< MemArray< 1, Eagle::PhysicalSpace::point > > &InputVertices, const double edge2D_max)
	interface to http://qhull.org/ version qhull-2015.2
RefPtr< MemBase >	PartialDerivative (const RefPtr< MemBase > &SourceData)
bool	isPartialDerivable (const RefPtr< CreativeArrayBase > &CAB)
	Check if the partial derivative can be computed from the given data.
RefPtr< CreativeArrayBase >	PartialDerivative (const RefPtr< CreativeArrayBase > &CAB, string &FailureDescription, const RefPtr< MemCore::Cache > &Cache)
RefPtr< Field >	PartialDerivative (Field &F, const string &GradientFieldname, Representation &CurrentRepresentation, Representation &FieldIDSource, string &FailureDescription, const RefPtr< MemCore::Cache > &Cache=MemCore::Cache::MemCache())
	Compute a Field that is the partial derivative of the given field in the specified representation.
template void	GridEvaluator::findForSpecificDestinationPositions< DirectProductMemArray< Eagle::point3, LinearCoordinateAxisArray, 3 > > (const DirectProductMemArray< Eagle::point3, LinearCoordinateAxisArray, 3 > &, const Field &SourcePositions, GridEvaluator::Context &theEvaluationContext)
Grid &	ComputeIsosurface (double Isolevel, const Ageable &Trigger, const Grid &RegularGrid, const string &fieldname, Slice &TimeStep, const string &isosurfacename, double precision)
	Compute an isosurface as a new Grid object from a scalar field given on a regular grid.
point	VertexInterp (double isolevel, const point &p1, const point &p2, double valp1, double valp2)
template<class CellValueType , class CellCoordinateType , class TriangleArrayType >
int	GeometricPolygonise (const CellValueType &CellValues, const CellCoordinateType &CellCoordinates, double isolevel, TriangleArrayType &triangles, double precision=1E-4)
void	CheckPolygonizer ()
TriangleSurface_t	ComputeIsosurface (double Isolevel, const MultiArray< 3, double > &ScalarField, const MultiArray< 3,::Eagle::PhysicalSpace::point > &VertexField, double precision)
TriangleSurface_t	ComputeIsosurface (double Isolevel, const MultiArray< 3, uint8_t > &ScalarField, const MultiArray< 3,::Eagle::PhysicalSpace::point > &VertexField, double precision)
template<class ValueType , Dims_t Dims, class ResultType >
void	ComputeInterpolationEdgeAndWeight (index_t &EdgeID, int &EdgeOrientation, ResultType &Weight, const FieldExplorer< MultiArray< Dims, ValueType > > &FE, const MultiIndex< Dims > &FirstVertex, const MultiIndex< Dims > &SecondVertex, const ResultType &precision)
	Given an value, and field with two vertices to evaluate at, compute the weight that each of the vertices have on the value.
template<class ArrayType >
int	Polygonize (std::vector< index_t > &IsoVertexEdge, std::vector< double > &IsoVertexWeight, std::vector< TriangleCell > &IsoSurfaceTriangles, map< index_t, index_t > &IsosurfaceVerticesAsEdges, const FieldExplorer< ArrayType > &FE, const MultiIndex< 3 > &CellIndex, double precision, index_t EdgeOffset=0)
	Create polygons out of a given field to be explored, based on the algorithm described by http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/.
template<class VertexFieldType >
void	EvalVertexFieldOnEdges (std::vector< typename VertexFieldType::value_type > &EvaluatedField, const std::vector< index_t > &Edges, const std::vector< double > &Weights, const VertexFieldType &RegularField, const MultiIndex< 3 > &FragmentSize, const MultiIndex< 3 > &FragmentOffset, index_t StartEvaluationAtVertex=0, index_t EdgeOffset=0)
	Given a set of edge indices and weights on them, plus a field defined on the vertices of a regular grid, comput a field that contains the weighted values of that field on the points at the edges.
template<class VertexField_t , class ArrayType >
gridop_API TriangleSurface_t	ComputeIsosurfaceT (const FieldExplorer< ArrayType > &FE, const VertexField_t &VertexField, double precision)
template<size_t N>
size_t	findNClosestPoints (const Eagle::point3 &QueryPoint, const nanoflannKDTree &theTree, std::array< uint32_t, N > &indices, std::array< double, N > &squared_distances)
template<class FragmentContext , class RecursionCriterium >
bool	ConditionalRecursion (const RefPtr< Grid > &G, const SkeletonID &ParentSid, const RefPtr< FragmentID > &ParentID, const RefinementAllowanceFunction< FragmentContext > &isAllowedFragment, const RefinementContinuationFunction< FragmentContext, RecursionCriterium > &wantFurtherRefinement, const RefinementFragmentEmitFunction< RecursionCriterium > &emitKid, const RecursionCriterium &ParentFragmentCriteria)
template<class FragmentContext , class RecursionCriterium >
void	RefinementRecursion (const RefPtr< Grid > &G, const SkeletonID &ConnectivitySid, const RefPtr< Field > &ConnectivityField, const RefinementAllowanceFunction< FragmentContext > &isAllowedFragment, const RefinementContinuationFunction< FragmentContext, RecursionCriterium > &wantFurtherRefinement, const RefinementFragmentEmitFunction< RecursionCriterium > &emitKid, const RecursionCriterium &ParentFragmentCriteria)
template<class FragmentContext , class RecursionCriterium >
void	RefinementRecursion (const RefPtr< Grid > &G, const SkeletonID &ConnectivitySid, const RefPtr< Skeleton > &Vertices, const RefinementAllowanceFunction< FragmentContext > &isAllowedFragment, const RefinementContinuationFunction< FragmentContext, RecursionCriterium > &wantFurtherRefinement, const RefinementFragmentEmitFunction< RecursionCriterium > &emitKid, const RecursionCriterium &ParentFragmentCriteria)
template<class FragmentContext , class RecursionCriterium >
void	RefinementRecursion (const RefPtr< Grid > &G, const SkeletonID &ConnectivitySid, const RefinementAllowanceFunction< FragmentContext > &isAllowedFragment, const RefinementContinuationFunction< FragmentContext, RecursionCriterium > &wantFurtherRefinement, const RefinementFragmentEmitFunction< RecursionCriterium > &emitKid, const RecursionCriterium &ParentFragmentCriteria)
RefPtr< Grid >	refineSurface (Bundle &B, const RefPtr< Grid > &InputGrid, const SurfaceRefinementCriterion &Criterion)
	Refine a surface according to the specified criteria.
point	midpoint (const point &v1, const point &v2)
point	midpoint (const point &v1, const point &v2, double radius, const point &center)
TriangleCell	OrientTriangleEdges (const TriangleCell &t, const TriangleCell &face2Edges, const MultiArray< 1, EdgeCell > &edgeList)
void	TriangleVerticesOrientation (const TriangleCell &t, const EdgeCell &e, unsigned &v1, unsigned &v2, unsigned &v3)
void	GenerateEdge2FacesTable (MultiArray< 1, EdgeCell > &edge2Faces, const MultiArray< 1, TriangleCell > &triangleList, const MultiArray< 1, EdgeCell > &edgeList, int faceCount, int edgeCount)
void	GenerateFace2EdgesTable (MultiArray< 1, TriangleCell > &face2Edges, const MultiArray< 1, EdgeCell > &edge2Faces, const MultiArray< 1, TriangleCell > &triangleList, const MultiArray< 1, EdgeCell > &edgeList, int oldEdge2FacesCount, int oldFaceCount)
RefPtr< Grid >	SplitMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid, const std::vector< bool > &modifyEdges)
RefPtr< Grid >	RadialSplitMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid, const std::vector< bool > &modifyEdges, double radius, const point &center)
RefPtr< Grid >	SplitMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid)
	Experimental refinement code.
bool	DelaunayCriterion2D (const point &v1, const point &v2, const point &v3, const point &v4)
RefPtr< Grid >	FlipMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid, const std::vector< bool > &flipableEdges)
RefPtr< Grid >	FlipMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid, double threshold)
RefPtr< Grid >	createUniformGrid3D (BundlePtr bp, double time, const string &grid_name, const Eagle::BoundingBox &bb, const MultiIndex< 3 > &dims)
RefPtr< Grid >	createRegularlyFragmentedClusteredPointCloudGrid (BundlePtr bp, double time, const string &grid_name, const MultiIndex< 3 > &nr_fragments, const RefPtr< Eagle::BoundingBox > &bb)
RefPtr< Grid >	createRegularlyFragmentedGridWithCartesianVertices3D (BundlePtr bp, double time, const string &grid_name, const MultiIndex< 3 > &nr_fragments)
RefPtr< Field >	ResampleRegularGrid3D (Grid &OutputGrid, const Grid &InputGrid, const string &Fieldname, const FixedArray< double, 3 > &IndexScale, const string &ChartName)
template<Dims_t Dims, typename DestType , typename SrcType , class Converter = PlainCopyConvert>
MultiArray< Dims, DestType > &	Resample (MultiArray< Dims, DestType > &DestData, const MultiArray< Dims, SrcType > &SourceData, const MultiIndex< Dims > &DestOffset=MultiIndex< Dims >(), const MultiIndex< Dims > &SourceOffset=MultiIndex< Dims >(), const Converter &C=Converter())
RefPtr< MemBase >	rescale (double scale, const RefPtr< MemBase > &Data, const MemBase::Creator_t &Crec)
std::vector< int8_t >	computeInt8SelectionByShape (const std::vector< Eagle::PhysicalSpace::point > &polygon_coords, const std::vector< LineSet::LineIndices_t > &polygon_indices, const std::vector< Eagle::PhysicalSpace::point > &pointcloud, const RefPtr< Eagle::BoundingBox > &frag_bbox)
RefPtr< Chunk< bool > >	computeIndicesSelectionByShape (const std::vector< Eagle::PhysicalSpace::point > &polygon_coords, const std::vector< LineSet::LineIndices_t > &polygon_indices, const std::vector< Eagle::PhysicalSpace::point > &pointcloud, const RefPtr< Eagle::BoundingBox > &frag_bbox)
RefPtr< Chunk< uint32_t > >	computeIndicesSelectionByShape (const std::vector< Eagle::PhysicalSpace::point > &polygon_coords, const std::vector< LineSet::LineIndices_t > &polygon_indices, const std::vector< Eagle::PhysicalSpace::point > &pointcloud, const RefPtr< Eagle::BoundingBox > &frag_bbox, bool Inverse)
RefPtr< MemArray< 1, Eagle::tvector3 > >	ComputeTangentialVectors (const MemArray< 1, Eagle::point3 > &Vertices, const MemArray< 1, std::vector< index_t > > &EdgesArray, const MemBase::Creator_t &Crec)
	Compute tangential vectors along a set of lines.
RefPtr< MemArray< 1, Eagle::tvector3 > >	getTangentialVectors (Grid &G, const string &FieldName=TangentialVectorFieldName)
	Compute tangential vectors in a grid object, which has a set of lines defined.
template<int N, class T , class C >
MemCore::RefPtr< Eagle::KDTree< N, T > >	createTree (const C &coordinates, const unsigned size)
	create a KDTree
template<int N, class T , class C >
MemCore::RefPtr< Eagle::KDTree< N, T > >	createTree (const C &coordinates, const unsigned size, const MemCore::RefPtr< Fiber::CreativeArrayBase > &cab)
	create a KDTree with caching of the data
template<class T >
MemCore::RefPtr< Eagle::OcTree< T > >	createOcTree (const MultiArray< 1, Eagle::PhysicalSpace::point > &coordinates, const size_t size, const RefPtr< Eagle::BoundingBox > &bb)
template<class T >
MemCore::RefPtr< Eagle::QuadTree< T > >	createQuadTree (const MultiArray< 1, Eagle::PhysicalSpace::point > &coordinates, const size_t size, const RefPtr< Eagle::BoundingBox > &bb)
RefPtr< Grid >	createUniformGrid (const string &InputGridname, const Info< Skeleton > &Level, const string &OutputGridname, const MultiIndex< 3 > &Resolution, const RefPtr< BoundingBox > &SubBox)
gridop_API RefPtr< Grid >	prepareRegularlyFragmentedGrid (BundlePtr bp, double time, const string &grid_name, int grid_dimensionality, const RefPtr< RegularlyFragmentedField< 3 > > &positions, const BoundingBox &bb)
bool	createPersistentRegularlyPositionFragments (const RefPtr< RegularlyFragmentedField< 3 > > &positions, const std::list< std::pair< MultiIndex< 3 >, RefPtr< UniformCartesianArray > > > &frags)
	Function to create regularly fragmented positions from a specifiyed list of RefPtr<UniformCartesianArray>s.
bool	uniformCellFromPosition (const point &base_crds, const point &m_min, const tvector &m_diag, const MultiIndex< 3 > &size, MultiIndex< 3 > &raster_frag)
bool	uniformCellFromPosition (const point &crds, const RefPtr< BoundingBox > &bb, const double &delta_s, const MultiIndex< 3 > &size, MultiIndex< 3 > &idx3)
bool	isPositionInInnerRegion (const point &base_crds, const point &t_min, const tvector &t_diag, const MultiIndex< 3 > &idx3, double distance_from_borders)
int	getCellsWherePointIsInGhostZone (const MultiIndex< 3 > &current, const MultiIndex< 3 > &max_cells, const point &pos, const point &t_min, const tvector &t_diag, double ghost_r, FixedArray< MultiIndex< 3 >, 7 > &cells)
gridop_API RefPtr< Grid >	DEPRECATED ("Use grid/types/RegularGrid3D.hpp:UniformGrid3D instead", createUniformGrid(const string &InputGridname, const Info< Skeleton > &Level, const string &OutputGridname, const MultiIndex< 3 > &Resolution, const RefPtr< Eagle::BoundingBox > &SubBox=NullPtr()))
	Create a uniform Grid from a given Grid.
gridop_API RefPtr< Grid >	DEPRECATED ("Use grid/types/RegularlyFragmentedGrid.hpp: instead", prepareRegularlyFragmentedGrid(BundlePtr bp, double time, const string &grid_name, int grid_dimensionality, const RefPtr< RegularlyFragmentedField< 3 > > &positions, const Eagle::BoundingBox &bb))
	Prepare a uniform regularly fragmented uniform grid from a given bounding box and number of fragments.
gridop_API bool	uniformCellFromPosition (const Eagle::PhysicalSpace::point &crds, const RefPtr< Eagle::BoundingBox > &bb, const double &delta_s, const MultiIndex< 3 > &size, MultiIndex< 3 > &idx3)
void	MapToUniform (MultiArray< 3, double > &Heightfield, const UniformCartesianArray &UMap, const MemCore::TypedChunkBase< FixedArray< double, 3 > > &, std::vector< index_t > &IndexArray, int Component=2, const FixedArray< double, 3 > &Numericalshift={0., 0., 0.})
	Insert data to a height field.
RefPtr< MemArray< 3, double > >	MapToUniform (const UniformCartesianArray &UMap, TypedChunkBase< FixedArray< double, 3 > > &Src, double InvalidData, int Component, const FixedArray< double, 3 > &NumericalShift)
MapToUniformIndexResult_t	MapToUniformIndex (const UniformCartesianArray &UMap, MemCore::TypedChunkBase< FixedArray< double, 3 > > &Src, double InvalidData, int Component, const FixedArray< double, 3 > &NumericalShift)
	Create a height field with an index array that allows to reproduce the mapping on other data arrays.
RefPtr< MemArray< 3, double > >	MapToUniform (const UniformCartesianArray &UMap, TypedChunkBase< FixedArray< float, 3 > > &, int Component, const FixedArray< double, 3 > &Numericalshift)
bool	MapFromUniform (TypedChunkBase< FixedArray< double, 3 > > &Result, const UniformCartesianArray &UMap, const RefPtr< MemArray< 3, double > > &Heightfield, int Component, const FixedArray< double, 3 > &Numericalshift)
void	InterpolateUniformHeight (MemCore::TypedChunkBase< FixedArray< double, 3 > > &Dest, const UniformCartesianArray &UMap, const MultiArray< 3, double > &Heightfield, int Component=2, const FixedArray< double, 3 > &Numericalshift={0., 0., 0.}, double HeightSlice=0.0)
	Given an array of points (derived from FixedArray<double> ), replace the given component by an interpolated value from the given height field placed on the uniform array.
template<typename T >
void	TInterpolateUniformHeightfield (TypedChunkBase< FixedArray< double, 3 > > &Dest, const std::vector< size_t > &IndexArray, const UniformCartesianArray &UMap, const MultiArray< 3, T > &Heightfield, int Component, const FixedArray< double, 3 > &Numericalshift, double HeightSlice)
ostream &	operator<< (ostream &os, const rgb_t &x)
void	TInterpolateUniformDataRGB (TypedChunk< rgb_t > &Dest, const std::vector< Eagle::point3 > &DestCoordinates, const UniformCartesianArray &UniformCoordinates, const MultiArray< 3, rgb_t > &UniformDatafield, const FixedArray< double, 3 > &Numericalshift, const std::function< bool(index_t, const Eagle::point3 &)> &EvaluationConstraint)
template<typename T >
void	TInterpolateUniformData (TypedChunk< T > &Dest, const std::vector< Eagle::point3 > &DestCoordinates, const UniformCartesianArray &UniformCoordinates, const MultiArray< 3, T > &UniformDatafield, const FixedArray< double, 3 > &Numericalshift, const std::function< bool(index_t, const Eagle::point3 &)> &EvaluationConstraint)
void	InterpolateUniformData (RefPtr< ChunkBase > &Dest, const std::vector< Eagle::point3 > &DestCoordinates, const UniformCartesianArray &UniformCoordinates, const RefPtr< MemBase > &UniformDatafield, const FixedArray< double, 3 > &Numericalshift={0, 0, 0}, const std::function< bool(index_t, const Eagle::point3 &)> &EvaluationConstraint=nullptr)
bool	UseThisField (const std::string &HaveThisField, const std::set< std::string > &myFields)
bool	intersect (BoundingBox &a, BoundingBox &b)
std::string	InterpolateUniformDataOnGrid (Grid &Dest, const Grid &UniformSource, const std::set< std::string > &myFields, const MemCore::RefPtr< MemCore::LoaderProgress > &theProgress)
void	InterpolateUniformHeightfieldOnCoords (TypedChunkBase< FixedArray< double, 3 > > &Dest, FragmentedUniformGrid3D &UGrid, const RegularlyFragmentedField< 3 > &Heightfield, int Component)
void	InterpolateUniformHeightfieldOnGrid (Grid &Dest, FragmentedUniformGrid3D &UGrid, const RegularlyFragmentedField< 3 > &Heightfield, int Component)
gridop_API RefPtr< MemArray< 3, double > >	MapToUniform (const UniformCartesianArray &UMap, const MemCore::TypedChunkBase< FixedArray< double, 3 > > &, double InvalidData, int Component=2, const FixedArray< double, 3 > &Numericalshift={0., 0., 0.})
	Create a height field.
gridop_API void	MapToUniform (MultiArray< 3, double > &Dest, const UniformCartesianArray &UMap, const MemCore::TypedChunkBase< FixedArray< float, 3 > > &, int Component=2, const FixedArray< double, 3 > &Numericalshift={0., 0., 0.})
gridop_API bool	MapFromUniform (MemCore::TypedChunkBase< FixedArray< float, 3 > > &Result, const UniformCartesianArray &UMap, const RefPtr< MemArray< 3, double > > &Heightfield, int Component=2, const FixedArray< double, 3 > &Numericalshift={0., 0., 0.})
gridop_API void	InterpolateUniformHeightfield (MemCore::TypedChunkBase< FixedArray< double, 3 > > &Dest, const std::vector< size_t > &IndexArray, const UniformCartesianArray &UMap, const MultiArray< 3, double > &Heightfield, int Component=2, const FixedArray< double, 3 > &Numericalshift={0., 0., 0.}, double HeightSlice=0.0)
	Given an indexed array of points (derived from FixedArray<double> ), replace the given component by an interpolated value from the given height field placed on the uniform array.
template<>
std::string	element_to_string (const list< MultiIndex< 3 > > &)
void	fillVertexSelection (RefPtr< Grid > &grid, RefPtr< MemArray< 1, VertexSelection_t > > &selection)
	Fill vertex selection by selecting all points inside the convex hull (3D) of the selection.
void	growVertexSelection (RefPtr< Grid > &grid, RefPtr< MemArray< 1, VertexSelection_t > > &selection, double radius)
bool	getBoundsHelper (const MemCore::RefPtr< Fiber::Representation > &representation, MemCore::RefPtr< Fiber::MemArray< 1, VertexSelection_t > > &selection, MemCore::RefPtr< Eagle::BoundingBox > &bb)
RefPtr< BoundingBox >	getVertexSelectionBounds (RefPtr< Grid > &grid, RefPtr< VertexSelection > &vs)
RefPtr< BoundingBox >	getVertexSelectionBounds (RefPtr< Grid > &grid, RefPtr< MemArray< 1, VertexSelection_t > > &vs)
RefPtr< VertexSelection >	getVertexSelection (RefPtr< Grid > &grid, const std::string &sel_name)
RefPtr< VertexSelection >	getMergedVertexSelection (const MemCore::RefPtr< Fiber::Grid > &grid, const StringList &sel, bool reduce)
bool	addVertexSelection (RefPtr< Grid > &grid, const std::string &sel_name, const RefPtr< MemArray< 1, VertexSelection_t > > &sel_indices, int refinement_level)
RefPtr< Field >	getVertexSelectionPositions (RefPtr< Grid > &grid)
gridop_API RefPtr< Representation >	getRefinedCartesianRepresentation (const RefPtr< Grid > &grid, double time, int ref)
gridop_API RefPtr< Representation >	getRefinedCartesianRepresentation (GridSelector &gs, double time, int ref)
gridop_API RefPtr< Representation >	getUnRefinedCartesianRepresentation (const RefPtr< Grid > &grid, double time)
gridop_API RefPtr< Representation >	getUnRefinedCartesianRepresentation (GridSelector &gs, double time)
RefPtr< Field >	getRefinedCartesianVertexField (GridSelector &gs, double time, string field_name, int ref)
RefPtr< Field >	getUnRefinedCartesianVertexField (GridSelector &gs, double time, string field_name)
RefPtr< Field >	getCartesianVertexField (GridSelector &gs, double time, string field_name, int ref)
gridop_API void	growVertexSelection (MemCore::RefPtr< Fiber::Grid > &grid, MemCore::RefPtr< Fiber::MemArray< 1, VertexSelection_t > > &selection, double radius)
	Grows a vertex selection by a given radius.
gridop_API MemCore::RefPtr< Eagle::BoundingBox >	getVertexSelectionBounds (MemCore::RefPtr< Fiber::Grid > &grid, MemCore::RefPtr< VertexSelection > &vs)
gridop_API MemCore::RefPtr< Eagle::BoundingBox >	getVertexSelectionBounds (MemCore::RefPtr< Fiber::Grid > &grid, MemCore::RefPtr< Fiber::MemArray< 1, VertexSelection_t > > &vs)
gridop_API MemCore::RefPtr< VertexSelection >	getVertexSelection (MemCore::RefPtr< Fiber::Grid > &grid, const std::string &sel_name)
gridop_API bool	addVertexSelection (MemCore::RefPtr< Fiber::Grid > &grid, const std::string &sel_name, const MemCore::RefPtr< Fiber::MemArray< 1, VertexSelection_t > > &sel_indices, int refinement_level=-1)
	function doing the store into the bundle; to be moved to fiber later; replace an entry with the same name or appends
gridop_API MemCore::RefPtr< Fiber::Field >	getVertexSelectionPositions (MemCore::RefPtr< Fiber::Grid > &grid)
bool	hasProperty (const Bundle &B, const BundleProperty &BP)
bool	hasProperty (BundlePtr Bptr, const BundleProperty &BP)
bool	hasProperty (const GridSelector &GS, const BundleProperty &BP)
bool	operator== (const FieldSelection &L, const FieldSelection &R)
bool	operator== (const FieldSelector &L, const FieldSelector &R)
RefPtr< Field >	getPrimaryOwner (const CreativeArrayBase &C)
RefPtr< Representation >	getPrimaryOwner (const Field &F)
RefPtr< Skeleton >	getPrimaryOwner (const Representation &R)
RefPtr< Grid >	getPrimaryOwner (const Skeleton &K)
RefPtr< Slice >	getPrimaryOwner (const Grid &G)
RefPtr< Bundle >	getPrimaryOwner (const Slice &S)
RefPtr< Bundle >	getPrimaryBundle (const Slice &S)
RefPtr< Bundle >	getPrimaryBundle (const Grid &G)
RefPtr< Bundle >	getPrimaryBundle (const Skeleton &K)
RefPtr< Bundle >	getPrimaryBundle (const Representation &R)
RefPtr< Bundle >	getPrimaryBundle (const Field &F)
RefPtr< Bundle >	getPrimaryBundle (const CreativeArrayBase &C)
string	OpenSkyDataAllStates ()
GridSelector	getOpenSky (string &OpenSkyData, const RefPtr< Bundle > &B, const string &Gridname, const std::function< double(time_t)> &TimeConvertr, const string &Chartname)
GridSelector	getOpenSky (const RefPtr< Bundle > &B, const string &Gridname, const std::function< double(time_t)> &TimeConverter, const string &Chartname)
FiberAviation_API std::string	getOpenSkyStates ()
bool	FieldFSinit ()
template<class T >
void	FSprint (const T &)
template<>
void	FSprint (const double &d)
template<>
void	FSprint (const float &d)
template<int N, class Value >
void	FSprint (const FixedArray< N, Value > &FA)
template<int N, class Value >
void	FSprint (const Vector< N, Value > &V)
template<int N, class Value >
void	FSprint (const VVector< N, Value > &V)
template<int C, class value >
void	FSprint (const Row< C, value > &R)
template<class ChartType , class TensorType >
void	FSprint (const Tensor< ChartType, TensorType > &d)
template<class ChartType , class ScalarType >
void	FSprint (const Point< ChartType, ScalarType > &d)
bool	InitGDALReader ()
bool	InitGDALSaver ()
bool	FiberIOGDALinit ()
herr_t	ConvertTriangleNamingConventionIJKtoII (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, size_t nelmts, size_t buf_stride, size_t bkg_stride, void *buf, void *bkg, hid_t dset_xfer_plist)
void	FiberIOHDF5cleanup ()
bool	FiberIOHDF5init ()
	Wrapper class for initialization.
RefPtr< MemBase >	LoadArray (CreativeArrayBase &theCreator, const string &Description, const DynamicSize &DS, size_t MemSize, F5Fragment &theH5DatasetContext, const RefPtr< StorageTransformations::IOPerformance > &IOP)
void	HDF5Load (RefPtr< Bundle > &Bndl, const string &url, const RefPtr< H5File > &theFile, const RefPtr< BundleLoaderProgress > &BLP, const RefPtr< StorageTransformations > &theStorageTransformations)
RefPtr< Loader< Bundle > >	newHDF5Loader ()
RefPtr< SizeInterface >	loadFieldSize (F5Path *field)
	Get a field's size without loading any data.
void	readGhostSizes (RefPtr< CreativeArrayBase > &cab, F5Path *f, const char *fragmentname="")
	Experimental function to store original field type as an field attribute.
void	readDictionary (const RefPtr< CreativeArrayBase > &cab, F5Path *f, const char *fragmentname)
RefPtr< Field >	ContiguousField (F5Path *field, const RefPtr< FragmentIDCollection > &theFragmentIDCollection, const char *RepresentationName, const RefPtr< FiberIO::HDF5::FileNameInterface > &RepresentationFilePath, const string &fieldname, Grid &theGrid, const FiberIO::HDF5::PrecisionTransformation &PT, const RefPtr< LoaderProgress > &TheLoaderProgressor, const WeakPtr< StorageTransformations::IOPerformance > &theLoadPerformance)
RefPtr< Field >	UniformField (F5Path *field, const RefPtr< FragmentIDCollection > &theFragmentIDCollection, const RefPtr< LoaderProgress > &TheLoaderProgressor)
template<int Dims>
bool	saveDimensions (MultiIndex< Dims > &dims, F5Path *field, const char *attribute_name, hid_t id)
	Save an n-dimensional attribute to an HDF5 ID and apply dimensional permutation according to the given field.
template<class IteratorContainer >
void	F5IterateTopologies (IteratorContainer &I, F5Path *grid, herr_t(IteratorContainer::*Iterator)(F5Path *skeleton, const char *skeletonname, int index_depth, int skel_dims))
bool	saveImage (const string &filename, const RefPtr< MemBase > &ImageData)
bool	initPNGSaver ()
bool	LoadImageSequence (RefPtr< Bundle > &Bndl, const RefPtr< LoaderParameters > &LP)
void	LoadImageSequence (const RefPtr< Bundle > &Bndl, const string &url)
FiberIOImageSequence_API std::string	SaveAsPNG (FILE *fp, const std::string &DestinationFile, const RefPtr< MemBase > &Image, const MemCore::Attributes &A, const MemCore::RefPtr< MemCore::LoaderProgress > &theProgress)
FiberIOImageSequence_API std::string	SaveAsPNG (FILE *fp, const std::string &OutfileName, const MultiArray< 2, Eagle::rgba16_t > &ImageData, const MemCore::Attributes &A, const MemCore::RefPtr< MemCore::LoaderProgress > &theProgress)
int	IOinit ()
	Initialize I/O layers for pre-defined template instantiations.
bool	FiberIOKmlinit ()
void	polygon (KmlFactory *factory, const std::vector< uint32_t > &ConCur, std::vector< point > &Points, const string &PlacemarkName, DocumentPtr &doc, CoordinatesPtr &coordinates)
void	line (KmlFactory *factory, const std::vector< uint32_t > &ConCur, std::vector< point > &Points, const string &PlacemarkName, DocumentPtr &doc, CoordinatesPtr &coordinates)
bool	saveAsKml (const Bundle *BP, RefPtr< SaveParameters > &S)
bool	InitKmlReader ()
bool	FiberIOLasinit ()
bool	InitLasReader ()
int	long2tilex (double lon, int z)
int	lat2tiley (double lat, int z)
double	tilex2long (int x, int z)
double	tiley2lat (int y, int z)
FILE *	Download (const string &url, const string &AsFilename)
bool	FiberIOInitRawReader ()
bool	FiberIOSHAPEFILEinit ()
bool	FiberIOTIFFinit ()
template<typename T >
bool	writeToBuffer (TIFF *OutTIFF, const RefPtr< MemArray< 3, T > > &InputC, const RefPtr< CreativeArrayBase > &CABHole, const MultiIndex< 3 > &FragDims, const T &isHole)
bool	writeToGTIF (TIFF *OutTIFF, const RefPtr< BoundingBox > &FragBBox, const tvector &CellSize)
template<typename T >
T	iniTIFF (TIFF *OutTIFF, const MultiIndex< 3 > &FragDims, const tvector &CellSize)
bool	saveAsTiff (const Bundle *BP, RefPtr< SaveParameters > &S)
bool	InitTiffReader ()
bool	VTKinit ()
bool	FieldXMLinit ()
template<class T >
void	XMLprint (const T &)
template<>
void	XMLprint (const double &d)
template<>
void	XMLprint (const float &d)
template<int N, class Value >
void	XMLprint (const FixedArray< N, Value > &FA)
template<int N, class Value >
void	XMLprint (const Vector< N, Value > &V)
template<int N, class Value >
void	XMLprint (const VVector< N, Value > &V)
template<int C, class value >
void	XMLprint (const Row< C, value > &R)
template<class ChartType , class TensorType >
void	XMLprint (const Tensor< ChartType, TensorType > &d)
template<class ChartType , class ScalarType >
void	XMLprint (const Point< ChartType, ScalarType > &d)
void	add (Iterator< double > &result, const Iterator< double > &left, const Iterator< double > &right)
void	add (const RefPtr< MemBase > &result, const RefPtr< MemBase > &left, const RefPtr< MemBase > &right)
void	m ()
void	component (const RefPtr< MemBase > &result, const RefPtr< MemBase > &compound, int member)
template<int N, class T , class O >
RefPtr< MemArray< N, T > >	convertData (RefPtr< Field > &field, RefPtr< FragmentID > fid)
template<int N, class T >
RefPtr< MemArray< N, T > >	getConvertedData (RefPtr< Field > &field, RefPtr< FragmentID > fid)
RefPtr< DataRangeBase >	getFragmentRange (CreativeArrayBase &CAB, bool AsynchRequest, bool theAvoidDataLoading, const RefPtr< MemBase > &PossibleData)
	TODO: Go via a type registry.
RefPtr< DataRangeBase >	getFieldRange_internal (Field &F, string &ErrorMessage, bool AsynchRequest, bool theAvoidDataLoading)
	TODO: Go via a type registry.
void	checkit (const std::vector< double > &Data, const std::vector< FixedArray< double, 4 > > &arrayData)
template<typename Type >
void	computeRangeIt (Type &MinValue, Type &MaxValue, const Iterator< Type > &Data)
template<typename T >
void	computeRange (T &MinValue, T &MaxValue, const T *Data, size_t size)
template<typename T , typename index_t >
void	computeIndexedRange (T &MinValue, T &MaxValue, const T *Data, size_t size, const std::vector< index_t > &index_array)
template<typename T , Eagle::dimension_t N>
void	computeRange (Eagle::FixedArray< T, N > &MinValue, Eagle::FixedArray< T, N > &MaxValue, const Eagle::FixedArray< T, N > *Data, size_t size)
template<typename T , Eagle::dimension_t N, typename index_t >
void	computeIndexedRange (Eagle::FixedArray< T, N > &MinValue, Eagle::FixedArray< T, N > &MaxValue, const Eagle::FixedArray< T, N > *Data, size_t size, const std::vector< index_t > &index_array)
template<typename T , Eagle::dimension_t N>
void	computeRangeIt (Eagle::FixedArray< T, N > &MinValue, Eagle::FixedArray< T, N > &MaxValue, const Iterator< Eagle::FixedArray< T, N > > &Data)
template<typename Type >
void	computeRange (Type &MinValue, Type &MaxValue, const std::vector< Type > &Data)
template<typename Type , typename index_t >
void	computeIndexedRange (Type &MinValue, Type &MaxValue, const std::vector< Type > &Data, const std::vector< index_t > &index_array)
template void	computeRange< double > (double &MinValue, double &MaxValue, const std::vector< double > &Data)
template<class Type , class OtherType >
void	expand_by_other_minmax (Type &Minimum, Type &Maximum, const OtherType &OtherMinimum, const OtherType &OtherMaximum)
	Expand a range by a given type, which must be convertible.
template<class Type , class OtherType >
bool	contains_value (const Type &Minimum, const Type &Maximum, const OtherType &Value)
template<class Type >
auto	ComputeRangeFromDirectProduct (const RefPtr< MemBase > &ArrayBase)
template<>
auto	ComputeRangeFromDirectProduct< Eagle::point3 > (const RefPtr< MemBase > &ArrayBase)
template<class Type >
bool	Contains (CreativeArrayBase &CAB, const Type &Value, bool ComputeEventually)
template<typename... Type>
RefPtr< DataRangeBase >	getTypedFragmentRange (CreativeArrayBase &CAB, bool AsynchRequest, bool theAvoidDataLoading, const RefPtr< MemBase > &PossibleData=nullptr)
	{
template<typename... Type>
RefPtr< DataRangeBase >	getTypedFragmentRange (Field &F, const RefPtr< FragmentID > &fragmentID, bool AsynchRequest, bool theAvoidDataLoading, const RefPtr< MemBase > &PossibleData=nullptr)
	Get the range of a field fragment by iterating over a list of types.
template<typename... Type>
RefPtr< DataRangeBase >	getTypedFieldRange (Field &F, bool AsynchRequest, bool theAvoidDataLoading)
	Get the range of a field by iterating over a list of types.
template<typename First , typename... MoreTypes>
RefPtr< DataRangeBase >	recursive_getTypedRange (Field &F, bool AsynchRequest, bool theAvoidDataLoading)
	An alternative version of getTypedRange() which does not rely on a fold expression and achieves the same via recursion.
RefPtr< DataRangeBase >	getFragmentRange (Field &F, const RefPtr< FragmentID > &f, bool AsynchRequest=false, bool theAvoidDataLoading=false, const RefPtr< MemBase > &PossibleData=nullptr)
	Determine and eventually compute the numerical range of a field fragment.
RefPtr< DataRangeBase >	getFieldRange (Field &F, std::string &ErrorMessage, bool AsynchRequest=false, bool theAvoidDataLoading=false)
	Determine and eventually compute the numerical range of a field.
RefPtr< DataRangeBase >	getQuickFieldRange (Field &F, std::string &ErrorMessage, bool AsynchRequest=false)
	Determine and eventually compute the numerical range of a field without loading data, i.e.
RefPtr< DataRangeBase >	getFieldRange (Field &F, bool AsynchRequest=false, bool theAvoidDataLoading=false) PERFORMANCE_WARNING_1()
	Determine and eventually compute the numerical range of a field.
RefPtr< DataRangeBase >	getFieldRange (const RefPtr< Field > &F, bool AsynchRequest=false, bool theAvoidDataLoading=false)
RefPtr< Field >	BinaryDoubleAdditionComputationalField (const RefPtr< Field > &L, const RefPtr< Field > &R)
int	RegisterCellTypes ()
unsigned char	clamp_int_to_byte (int i)
unsigned char	clamp_flt_to_byte (double d)
rgb_real	mult (const rgb_real &l, const rgb_real &r)
template<class FieldOperator >
ComputationalField< FieldOperator > *	newComputationalField (const FieldOperator &FO, const RefPtr< Field > &InputField, const MemCore::RefPtr< MemCore::Cache > &theCache=MemCore::Cache::MemCache())
	A convenience template function to construct a computational field (class ComputationalField) from an instance of a FieldOperator.
template<class FieldOperator >
ComputationalField< FieldOperator > *	newComputationalField (const FieldOperator &FO, const Field &InputField, const MemCore::RefPtr< MemCore::Cache > &theCache=MemCore::Cache::MemCache())
	A convenience template function to construct a computational field (class ComputationalField) from an instance of a FieldOperator.
bool	CreateIndirection (const RefPtr< ChunkBase > &Dst, const RefPtr< ChunkBase > &Src, const std::vector< uint32_t > *indirection_dst, const std::vector< uint32_t > *indirection_src, index_t start, index_t end, int dst_offset, int src_offset, size_t ElementArraySize)
bool	CreateIndirection (const RefPtr< ChunkBase > &Dst, const RefPtr< ChunkBase > &Src, const std::vector< uint64_t > *indirection_dst, const std::vector< uint64_t > *indirection_src, index_t start, index_t end, int dst_offset, int src_offset, size_t ElementArraySize)
RefPtr< MemBase >	pullData (const RefPtr< MemBase > &SourceData, const RefPtr< ChunkBase > &Indirection, const DynamicSize &DestSize, size_t ElementArraySize=1)
	Create a MemBase from a given MemBase using indirect indexing of the given one, with the result placed into a multidimensional array.
RefPtr< MemBase >	pullData (const RefPtr< MemBase > &SourceData, const RefPtr< MemBase > &Indirection, size_t ElementArraySize)
template<class IndexType >
bool	CreateIndirectionPush (const RefPtr< ChunkBase > &Dst, const RefPtr< ChunkBase > &Src, const std::vector< IndexType > &indirection_dst, index_t start, index_t end, int dst_offset=0, int src_offset=0, size_t ElementArraySize=1)
template<class IndexType >
bool	CreateIndirectionPull (const RefPtr< ChunkBase > &Dst, const RefPtr< ChunkBase > &Src, const std::vector< IndexType > &indirection_src, index_t start, index_t end, int dst_offset=0, int src_offset=0, size_t ElementArraySize=1)
RefPtr< MemBase >	pullData (const RefPtr< MemBase > &SourceData, const DynamicSize &DestSize, const RefPtr< ChunkBase > &Indirection, size_t ElementArraySize=1)
bool	CreateSample (RefPtr< ChunkBase > &Dest, const RefPtr< ChunkBase > &Src, const SampleParameters &SP)
bool	CreateSample (const RefPtr< MemBase > &Dest, const RefPtr< MemBase > &Src, const SampleParameters &SP)
RefPtr< MemBase >	CreateSample (const RefPtr< MemBase > &Src, index_t DstElements, const SampleParameters &SP, const MemBase::Creator_t &C)
RefPtr< SizeInterface >	getSize (const CreativeArrayBase &CAB)
RefPtr< SizeInterface >	makeSize (CreativeArrayBase &CAB)
index_t	NumberOfElements (const RefPtr< CreativeArrayBase > &CAB)
MemCore::memsize_t	getMemoryUsage (const CreativeArrayBase &CAB)
RefPtr< MemBase >	getMemBase (const MemCore::WeakPtr< CreativeArrayBase > &MemDataCreator)
RefPtr< MemCore::ChunkBase >	getChunk (const MemCore::WeakPtr< CreativeArrayBase > &MemDataCreator)
RefPtr< MemBase >	operator- (const MemCore::WeakPtr< CreativeArrayBase > &MemDataCreator)
RefPtr< MemCore::ChunkBase >	operator+ (const MemCore::WeakPtr< CreativeArrayBase > &MemDataCreator)
RefPtr< SizeInterface >	makeSize (const RefPtr< CreativeArrayBase > &CAB)
void	temp ()
void	h (ElementProxy< Iterator< FixedArray< double, 3 > > > &out, ElementProxy< Iterator< FixedArray< double, 3 > > > &in)
void	g (Eagle::FixedArray< double, 3 > &M)
void	f (DirectProductMemArray< Eagle::FixedArray< double, 3 > >::MemArray_t &M)
RefPtr< SizeInterface >	operator+ (const RefPtr< SizeInterface > &L, const RefPtr< SizeInterface > &R)
int	getLinearIndex (const DynamicSize &theIndex, const DynamicSize &theSize)
size_t	ElementArraySize (const DynamicSize &FragmentBaseSpaceDims, const DynamicSize &DataFragmentDims) noexcept
bool	containsType (const TypeList_t &TL, const std::type_info &what)
	Investigate if a certain type is contained in a given type list.
bool	fieldSyntaxCheck (Field &F)
FieldFragment	operator<< (const RefPtr< Field > &F, const RefPtr< FragmentID > &Fid)
FieldFragment	operator<< (const RefPtr< Field > &F, const string &FragmentName)
RefPtr< CreativeArrayBase >	operator<< (const FieldFragment &&FF, const Field::CAB_t &theCreator)
FieldFragmentRef	operator<< (Field &F, const RefPtr< FragmentID > &Fid)
FieldFragmentRef	operator<< (Field &F, const string &FragmentName)
template<class Functor >
FunctionalCreator &	operator+= (const FieldFragmentRef &FieldFragment, const Functor &Lambda)
template<class Functor >
FunctionalCreator &	operator+= (const Field &F, const Functor &Lambda)
RefPtr< CreativeArrayBase >	operator<< (const FieldFragment &FF, const FunctionalCreator::Functor &F)
RefPtr< CreativeArrayBase >	operator<< (const FieldFragmentRef &FF, const FunctionalCreator::Functor &F)
template<class T >
int	operator<<= (const Field &F, const T &t)
template<class T >
int	operator<<= (const RefPtr< Field > &F, const T &t)
template<class FragmentOperator >
void	SetupNewFragmentCreators (const RefPtr< Field > &Output, const RefPtr< Field > &Input, FragmentOperator &Op)
template<>
std::string	element_to_string (const RefPtr< FragmentID > &fID)
template<>
std::string	element_to_string (const std::vector< RefPtr< FragmentID > > &fIDs)
template<>
std::string	element_to_string (const FragmentIDContainer &fID)
template<class Functor >
RefPtr< FunctionalCreator >	newFunctionalCreator (const Functor &F)
template<class T >
RefPtr< TypedArray< T > >	newMemArray (const DynamicSize &DS, const MemBase::Creator_t &C=nullptr)
template<class T >
RefPtr< MemArray< 1, T > >	makeMemArray1D (const RefPtr< MemCore::TypedChunk< T > > &DataChunk, const MemBase::Creator_t &C=MemCore::NullPtr())
	Create one-dimensional MemArray from provided data chunk.
template<class T >
RefPtr< MemArray< 1, T > >	makeMemArray1D (const RefPtr< MemCore::Chunk< T > > &DataChunk, const MemBase::Creator_t &C=MemCore::NullPtr())
	Create one-dimensional MemArray from provided data chunk.
template<Dims_t N>
bool	makeSizeInterface (MultiIndex< N > &Dims, const RefPtr< CreativeArrayBase > &DC)
	Set the size interface of a given data array Creator, based on the associated data (this function will actually CREATE the data - so is slow!).
template<Dims_t N>
bool	makeDimensions (MultiIndex< N > &Dims, const RefPtr< CreativeArrayBase > &DC)
	Given a data creator, retrieve the dimensionality information from the associated data, preferably from the size interface as stored (cached) in the Creator, but if none such exists yet, load the data and get it from there once.
RefPtr< MemCore::ChunkBase >	getChunk (const MemCore::WeakPtr< MemBase > &MemData)
RefPtr< MemCore::ChunkBase >	operator- (const RefPtr< MemBase > &Mem)
template<class T >
std::string	element_to_string (const T &element)
template<>
std::string	element_to_string (const std::string &element)
template<>
std::string	element_to_string (const std::vector< unsigned short > &EdgeList)
template<>
std::string	element_to_string (const std::vector< unsigned int > &EdgeList)
template<>
std::string	element_to_string (const std::vector< unsigned long > &EdgeList)
template<>
std::string	element_to_string (const std::vector< unsigned long long > &EdgeList)
RefPtr< Field >	newRegularlyFragmentedField (const DynamicSize &Sz)
bool	Shift (const RefPtr< ChunkBase > &Dst, const RefPtr< ChunkBase > &Src, const RefPtr< ChunkBase > &ShiftValue)
bool	Shift (const RefPtr< MemBase > &Dst, const RefPtr< MemBase > &Src, const RefPtr< ChunkBase > &ShiftValue)
RefPtr< MemBase >	Shift (const RefPtr< MemBase > &Src, const RefPtr< ChunkBase > &ShiftValue, const MemBase::Creator_t &C)
bool	ShiftInPlace (const RefPtr< ChunkBase > &Dst, const RefPtr< ChunkBase > &ShiftValue)
template<class T >
Iterator< T >	getComponentArrayIterator (const TypedArray< T > &It, int component)
template<class T , int Components>
Iterator< T >	getComponentArrayIterator (const TypedArray< FixedArray< T, Components > > &It, int component)
template<class Result_t , class T >
bool	applyFunctor (const TypedArray< Result_t > &Result, const TypedArray< T > &Data, const std::function< Result_t(const T &)> &func)
	Apply a unary functor to a TypedArray.
template<class Result_t , class T >
bool	applyFunctor (const TypedArray< Result_t > &Result, const TypedArray< T > &Data, const std::function< Result_t(index_t i, const T &)> &func)
	Apply a functor to a TypedArray that also wants to know the index of the current element, such to look up another array of the same size (for instance).
template<class Result_t , class T , class Operand_t >
bool	applyFunctor (const TypedArray< Result_t > &Result, const TypedArray< T > &L, const TypedArray< Operand_t > &R, const std::function< Result_t(const T &, const Operand_t &)> &func)
	Apply a binary functor to two TypedArray objects.
ChartCreatorRegistry_t &	ChartCreatorRegistry ()
RefPtr< Field >	getCoordinates (const CoordinateRepresentationReference &CRR)
RefPtr< Field >	getCoordinates (const CoordinateRepresentationReference &CRR, const string &fieldname)
RefPtr< Field >	operator+ (const RefPtr< Representation > &R)
RefPtr< Field >	operator+ (const Representation &R)
RefPtr< Field >	operator+ (const RefPtr< Representation > &R, const string &Fieldname)
RefPtr< Field >	operator+ (const Representation &R, const string &Fieldname)
int	pullFragments (Representation &Dst, const RefPtr< FragmentID > &DstID, const Representation &src, const RefPtr< FragmentID > &SrcID, const RefPtr< ChunkBase > &Indirection, const DynamicSize &DestSize)
GRID_API int	pullFragments (Representation &Dst, const RefPtr< FragmentID > &DstID, const Representation &src, const RefPtr< FragmentID > &SrcID, const RefPtr< MemCore::ChunkBase > &Indirection, const DynamicSize &DestSize)
	Pull all data fields from a source representation into a destination representation via the given indirection array.
template<class Functor >
int	operator<<= (const Representation &R, const Functor &F)
	Apply lambda function to represention to iterate over the fields in here.
template<class Functor >
int	operator<<= (const RefPtr< Representation > &R, const Functor &F)
	Apply lambda function to pointer to represention to iterate over the fields in here, in case it's a valid pointer.
RefPtr< Representation >	get (const RepresentationReference &R)
RefPtr< Representation >	get (const CoordinateRepresentationReference &R)
RefPtr< Representation >	operator* (const RepresentationReference &R)
RefPtr< Representation >	operator* (const CoordinateRepresentationReference &R)
std::string	to_string (const Skeleton &S)
template<size_t NumberOfFields>
auto	getCreators (const std::array< RefPtr< Field >, NumberOfFields > &Fields, const RefPtr< FragmentID > &fID)
template<>
std::string	element_to_string (const FEMFaceList_t &EdgeList)
template<>
std::string	element_to_string (const FEMDirections_t &FEM)
template<class T >
void	initValues (T &foo)
template<>
void	initValues< float > (float &foo)
template<>
void	initValues< double > (double &foo)
template<>
void	initValues< Eagle::PhysicalSpace::tvector > (Eagle::PhysicalSpace::tvector &foo)
template<>
void	initValues< Eagle::metric33 > (Eagle::metric33 &foo)
MultiIndex< 3 >	IsLargerThan (const MultiIndex< 3 > &I, const MultiIndex< 3 > &CompareValue=MultiIndex< 3 >({0, 0, 0}), const MultiIndex< 3 > &Yes=MultiIndex< 3 >({1, 1, 1}), const MultiIndex< 3 > &No=MultiIndex< 3 >({0, 0, 0}))
	Check if fragidx is at border: First Case: e.g we are at the left border, that is, I is larger than 0 Second Case: we are at the right border, I is larger than Number of Fragments + 2! Note: For Second Case Yes/No is swoped.
SkeletonID	FragmentSkeletonID (const SkeletonID &S, int NewDimension)
RefPtr< Chunk< Eagle::PhysicalSpace::point > >	findPoints (const Eagle::PhysicalSpace::point &query_position, double radius)
RefPtr< Chunk< Eagle::PhysicalSpace::point > >	findPoints (const Eagle::PhysicalSpace::point &query_position, double radius, const MultiIndex< 3 > &frag_index)
SkeletonID	computeFragmentSkeletonID (const DynamicSize &Fragmentation, const SkeletonID &SID)
SkeletonID	computeFragmentSkeletonID (const Field &F, const SkeletonID &SID)
bool	createRegularlyFragmentedSkeleton (Grid &theGrid, const RefPtr< Skeleton > &theSkeletonOfInterest, const FragmentIDCollection &FIC)
bool	createRegularlyFragmentedSkeleton (Grid &theGrid, const Skeleton &theSkeletonOfInterest, const FragmentIDCollection &FIC)
bool	createRegularlyFragmentedSkeleton (Grid &theGrid, const RefPtr< Skeleton > &theSkeletonOfInterest, const Field &FragmentedField)
bool	createRegularlyFragmentedSkeleton (Grid &theGrid, const RefPtr< Skeleton > &theSkeletonOfInterest)
bool	createRegularlyFragmentedSkeleton (Grid &theGrid, const Skeleton &theSkeletonOfInterest)
TriangleEdge	findAdjacentTriangle (index_t V1, index_t V2, TriangularSurface &TS, index_t firstTriangle, index_t lastTriangle)
bool	containedInCell (uint32_t idx, const TriangleCell &t)
int	RegisterStandardCharts ()
int	RegisterColorMemArrayTypes ()
int	RegisterIntegerStandardMemArrayTypes ()
int	RegisterLongMemArrayTypes ()
int	RegisterShortIntegerStandardMemArrayTypes ()
int	RegisterMemArrayTypes ()
	Register allocation objects for types such that MemArrays can be created via the virtual MemBase::create() API based on abstract type information.
int	RegisterStandardDoubleMemArrayTypes ()
int	RegisterStandardFloatMemArrayTypes ()
bool	CheckFiniteDifferencing ()
template<Dims_t Dims, typename Value , typename ResultType >
const MultiArray< Dims, ResultType > &	ComputeDerivative (MultiArray< Dims, ResultType > &result, const MultiArray< Dims, Value > &ValueField)
	Compute the derivative of a multidimensional array.
constexpr int	log2 (index_t arg)
	Compute the logarithm to the basis of two from the given index.
constexpr index_t	RoundUpToNextHighestPowerOf2 (index_t v)
	Align a value to the next fitting power of 2.
constexpr index_t	clamp (index_t value, index_t range)
constexpr index_t	clamp_m1 (index_t value, index_t range)
constexpr index_t	clamp (index_t low_range, index_t value, index_t high_range)
template<class VectorType >
Iterator< typename FixedArrayTrait< typename Eagle::MetaInfo< VectorType >::element_t, Eagle::MetaInfo< VectorType >::MULTIPLICITY >::array_t >	farray_iterator (const Iterator< VectorType > &V)
	Convert an iterator to a contiguous array of vectors into an iterator over elements which are FixedArrays.
template<class Type >
Iterator< Type >	array_iterator (const Iterator< Type > &It)
	Specialization of the array_iterator() function for Iterators on what is already a FixedArray.
template<class Type >
Iterator< Type >	array_iterator (const Iterator< FixedArray< Type, 1 > > &It)
template<int N, class Type >
Iterator< Eagle::Vector< Type, N > >	vector_iterator (const Iterator< Eagle::VVector< N, Type > > &It)
template<int N, class T >
std::string	mkString (const Fiber::MultiArray< N, T > &M)
template<class Dest , class Source , Dims_t N, class Converter >
void	Copy (MultiArray< N, Dest > &DestArray, const MultiArray< N, Source > &SrcArray, const Converter &C)
	Copy data from the source array to the destination array, whereby the destination array must be larger than or equal to the source array.
template<class Dest , class Source , Dims_t N, class Converter >
void	Copy (MultiArray< N, Dest > &DestArray, const MultiIndex< N > &DestOffset, const MultiArray< N, Source > &SrcArray, const Converter &C)
	Copy data from the source array to the destination array, whereby the destination array must be larger than or equal to the source array.
template<class Dest , class Source , Dims_t N, class Converter >
void	Copy (MultiArray< N, Dest > &DestArray, const MultiArray< N, Source > &SrcArray, const MultiIndex< N > &SrcOffset, const Converter &C)
	Copy data from the source array to the destination array, whereby the destination array must be larger than or equal to the source array.
template<class Dest , class Source , Dims_t N, class Converter >
void	Copy (MultiArray< N, Dest > &DestArray, const MultiIndex< N > &DestOffset, const MultiArray< N, Source > &SrcArray, const MultiIndex< N > &SrcOffset, const Converter &C)
	Copy data from the source array to the destination array, whereby the destination array must be larger than or equal to the source array.
template<class Dest , class Source , Dims_t N, class Converter >
void	CopySubset (const MultiIndex< N > &HowMany, MultiArray< N, Dest > &DestArray, const MultiIndex< N > &DestOffset, const MultiArray< N, Source > &SrcArray, const MultiIndex< N > &SrcOffset, const Converter &C)
	Copy a subset of data from the source array to the destination array.
constexpr MultiIndex< 1 >	MIndex (index_t i0)
constexpr MultiIndex< 2 >	MIndex (index_t i0, index_t i1)
constexpr MultiIndex< 3 >	MIndex (index_t i0, index_t i1, index_t i2)
constexpr MultiIndex< 4 >	MIndex (index_t i0, index_t i1, index_t i2, index_t i3)
template<Dims_t Dims>
MultiIndex< Dims >	isLargerThan (const MultiIndex< Dims > &I, const MultiIndex< Dims > &CompareValue=MultiIndex< Dims >(0), const MultiIndex< Dims > &Yes=MultiIndex< Dims >(1), const MultiIndex< Dims > &No=MultiIndex< Dims >(0))
template<Dims_t Dims, class Int >
MultiIndex< Dims >	operator* (const MultiIndex< Dims > &MIn, Int Factor)
template<Dims_t Dims, class Int >
MultiIndex< Dims > &	operator*= (MultiIndex< Dims > &M, Int Factor)
template<Dims_t Dims, class Int >
MultiIndex< Dims >	operator/ (const MultiIndex< Dims > &MIn, Int Factor)
template<Dims_t Dims, class Int >
MultiIndex< Dims > &	operator/= (MultiIndex< Dims > &M, Int Factor)
bool	CheckMultiOperate ()
bool	CheckMultiOperateOnArray ()
template<int IndexChart, typename Value , typename ResultType >
Eagle::Vector< ResultType, IndexChart > &	PartialDerivative (Eagle::Vector< ResultType, IndexChart > &result, const MultiArray< IndexChart, Value > &ValueField, const MultiIndex< IndexChart > &I)
	f,x (aU+bV),x = a(U,x)+b(V,x)
template<int N, typename T >
RefPtr< MemArray< N, T > >	getMemArrayViaMBase (RefPtr< Field > &myField, RefPtr< FragmentID > FragID=MemCore::NullPtr())
template<typename T >
RefPtr< MemCore::TypedChunk< T > >	getChunkOfField (RefPtr< Field > &myField, RefPtr< FragmentID > FragID=MemCore::NullPtr())
template<class LineIntegratorAnalyticContainer >
bool	setupAnalyticIntegrators (LineIntegratorAnalyticContainer &AnalyticLineIntegrators, const RefPtr< Field > &ToIntegrateField, double Time)
	Initialize a container of analytic line integrators with analytic functions as retrieved from a Field object.
template<int internalformat, typename TextureProbeType >
RefPtr< Wizt::GLTexture3D >	createScaledTexture3D (const RefPtr< MemBase > &Data, const type_info &TextureType, const Range &RemapToTarget, const MultiIndex< 3 > &Start, const MultiIndex< 3 > &End, const MultiIndex< 3 > &Step, int TextureUnit, GLenum format, const glMemSize< internalformat > &InternalFormat, int BitsPerTexel, double Gamma)
template<int internalformat>
RefPtr< Wizt::GLTexture3D >	createTexture3Di (const RefPtr< MemBase > &Data, const type_info &TextureType, const Range &RemapToTarget, const MultiIndex< 3 > &Start, const MultiIndex< 3 > &End, const MultiIndex< 3 > &Step, int TextureUnit, GLenum format, const glMemSize< internalformat > &InternalFormat, int BitsPerTexel, double Gamma)
RefPtr< Wizt::GLTexture3D >	createTexture3D (const RefPtr< MemBase > &Data, const type_info &TextureType, const Wizt::Range &R, const MultiIndex< 3 > &Start, const MultiIndex< 3 > &End, const MultiIndex< 3 > &Step, int TextureUnit, GLenum format, GLenum internalformat, int BitsPerTexel, double Gamma)
	Load data from a memory array to a 3D OpenGL texture, purely procedural version.
RefPtr< Wizt::GLTexture2D >	createTexture2D (const RefPtr< MemBase > &Data, const type_info &TextureType, const Range &R, const SliceSelection &O, const index_t &SliceNumber, int TextureUnit, GLenum format, GLenum internalformat, int BitsPerTexel)
	Extract 2D data slice from a 3D memory array to a 2D OpenGL texture.
int	renderVolume (VRenderContext &Context, int slices, const FixedArray< double, 3 > &TS, const FixedArray< double, 3 > &TOffset, const Eagle::point3 &Observer, const Eagle::point3 &BBoxMin, const Eagle::point3 &BBoxMax, int CancellationCheck, double CutDistance, bool CutInFrontOfCutDistance)
	TODO: Establish caching here via view point/observer direction and VBO's.
void	renderQuad (const RefPtr< GLTexture2D > &TXT, const Eagle::point3 &P00, const Eagle::point3 &P01, const Eagle::point3 &P10, const Eagle::point3 &P11)
fishGL_API RefPtr< Wizt::GLTexture2D >	createTexture2D (const RefPtr< MemBase > &Data, const type_info &TextureType, const Wizt::Range &R, int TextureUnit, GLenum format, GLenum internalformat, int BitsPerTexel)
	Load data from a 2D memory array to a 2D OpenGL texture.
template<int TextureFormat>
RefPtr< Wizt::GLTexture2D >	createTexture2D (const RefPtr< MemBase > &DataCreator, const std::type_info &TextureType, const Wizt::Range &R, int TextureUnit=0, GLenum format=GL_LUMINANCE, const glMemSize< TextureFormat > &Format=glMemSize< GL_RGBA >())
	Load data from a memory array to a 2D OpenGL texture, OpenGL texture format as specified by one of the glMemSize<> instantiations.
template<int TextureFormat>
RefPtr< Wizt::GLTexture2D >	createTexture2D (const RefPtr< MemBase > &DataCreator, const std::type_info &TextureType, const Wizt::Range &R, const SliceSelection &O, const index_t &SliceNumber, int TextureUnit=0, GLenum format=GL_LUMINANCE, const glMemSize< TextureFormat > &Format=glMemSize< GL_RGBA >())
	Load data from a 3D memory array to a 2D OpenGL texture, OpenGL texture format as specified by one of the glMemSize<> instantiations.
template<int TextureFormat>
RefPtr< Wizt::GLTexture3D >	createTexture3D (const RefPtr< MemBase > &DataCreator, const std::type_info &TextureType, const Wizt::Range &R, double Gamma, const MultiIndex< 3 > &Start=MIndex(0, 0, 0), const MultiIndex< 3 > &End=MIndex(0, 0, 0), const MultiIndex< 3 > &Step=MIndex(1, 1, 1), int TextureUnit=0, GLenum format=GL_LUMINANCE, const glMemSize< TextureFormat > &Format=glMemSize< GL_RGBA >())
	Load data from a memory array to a 3D OpenGL texture, OpenGL texture format as specified by one of the glMemSize<> instantiations.
fishGL_API void	renderQuad (const RefPtr< Wizt::GLTexture2D > &TXT, const Eagle::point3 &P00, const Eagle::point3 &P01, const Eagle::point3 &P10, const Eagle::point3 &P11)
template<>
string	element_to_string (const std::complex< double > &D)

Variables
const char *const	FIBER_COLOR_FIELD = "Color"
bool	DontUseCreatorRangeAttributeAsBoundingBoxDefault
const int	edgeTable [256]
const int	triTable [256][16]
const char	TangentialVectorFieldName [] = "Tangents"
	A default name for the field that holds the tangential vectors of a grid describing lines.
const char	CurveParameterFieldName [] = "length"
	A default name for the field that holds the respective values of a curve parameter.
class BUNDLE_API	Bundle
class BUNDLE_API	StorageTransformations
class BUNDLE_API	BundleProperty
class BUNDLE_API	GridList
class BUNDLE_API	SliceMap
class BUNDLE_API	Slice
class BUNDLE_API	GridSelector
Auto< FiberType< double > >	FT
class FIELD_API	FragmentIDCollection
class FIELD_API	FragmentIDContainer
class FIELD_API	MemBase
class FIELD_API	CreativeArrayBase
template class FIELD_API	RegularlyFragmentedField< 3 >
class GRID_API	Chart
class GRID_API	ChartCreatorBase
class GRID_API	Grid
class GRID_API	VertexFieldRef
constexpr const char	FIBER_POSITIONS [] = "Positions"
class GRID_API	Representation
class GRID_API	FieldRef
class GRID_API	SkeletonMap

Detailed Description

Given a fragmented field of curvilinear coordinates, (3D array of coordinates), build a uniform Grid object that contains a list of curvilinear cells per uniform cell.

Classes for constructing and operating on the Fiber Bundle data model.

Tiff export.

kml export

A class proving different methods for interpolation of data given on a point cloud.

Each uniform cell will contain a set of curvilinear cells specified by fragment index and multidimensional cell index per fragment.

Author

mniederwieser

Date

10 Feb 2015

Todo:

rewrite createTree into two polymorphic functions

Author

wolfg.nosp@m.ang..nosp@m.doble.nosp@m.r@gm.nosp@m.x.at

Werner Benger

Typedef Documentation

index_t

typedef IndexTypeConfig<sizeof(void*)>::index_t Fiber::index_t

Define the index type as according to the size of a pointer, i.e.

64 bit or 32 bit, depending on the compilation.

It is signed to allow detecting over- and underflows during indexing.

nanoflannKDTree

using Fiber::nanoflannKDTree = typedef nanoflann::KDTreeSingleIndexAdaptor< nanoflann::L2_Simple_Adaptor<double, NanoFlannPointCloudAdaptor>, NanoFlannPointCloudAdaptor, 3 >

Interface to the Nanoflann library: https://github.com/jlblancoc/nanoflann.

Usage:

• Smaller values (e.g. 1-5): deeper tree, faster queries but slower build time and more memory.
• Larger values (e.g. 20-50): shallower tree, faster build time but slower queries.

If your queries are very frequent and latency-critical, try leaf_max_size = 10. If you're doing batch queries or care more about build time, try leaf_max_size = 64 or even 128.

const int maximum_number_of_points_per_leaf_node = 10;
 
KDTree  index(3, adaptor, nanoflann::KDTreeSingleIndexAdaptorParams(maximum_number_of_points_per_leaf_node));
        index.buildIndex();

then do things such as findNClosestPoints();

Representer

typedef WeakPtr<BaseSpace> Fiber::Representer

The type used to reference other objects, which is the anchor of representations of a Skeleton.

The BaseSpace is a base class for chart objects as well as for other Skeleton objects.

Enumeration Type Documentation

DataCreationMode

enum Fiber::DataCreationMode

Under which conditions to create data when calling ExpandBBox().

Enumerator
AlwaysCreate	Always create data and even scan, if needed.
ComputeOrRequest	Compute bounding box only when data exists in memory, otherwise request them for a subsequent call.
ComputeOnlyIfAvailable	Compute bounding box only when data exists in memory, otherwise don't even request them.

Function Documentation

applyFunctor()

template<class Result_t , class T >

bool Fiber::applyFunctor	(	const TypedArray< Result_t > &	Result,
		const TypedArray< T > &	Data,
		const std::function< Result_t(const T &)> &	func
	)

Apply a unary functor to a TypedArray.

Example code:

RefPtr<TypedArray<double>> compute_something(TypedArray<point>>&Points )
{
RefPtr<TypedArray<double>> Distance = Points.create<double>();
        applyFunctor( *Distance, Points, [](const point&P) { return P.x() + P.y() - P.z(); } );
        return X;
}

References Fiber::HyperslabParameters::count().

array_iterator()

template<class Type >

Iterator< Type > Fiber::array_iterator ( const Iterator< Type > &  It )

inline

Specialization of the array_iterator() function for Iterators on what is already a FixedArray.

Here, we don't need a conversion at all, and this conversion is trivial.

Referenced by Fiber::Iterator< T >::getArrayIterator().

computeIndicesSelectionByShape()

RefPtr< Chunk< bool > > gridop_API Fiber::computeIndicesSelectionByShape	(	const std::vector< Eagle::PhysicalSpace::point > &	polygon_coords,
		const std::vector< LineSet::LineIndices_t > &	polygon_indices,
		const std::vector< Eagle::PhysicalSpace::point > &	pointcloud,
		const RefPtr< Eagle::BoundingBox > &	frag_bbox
	)

test if Eagle::PhysicalSpace::point lies inside of the polygon(s)
       distinction between 'inside' and 'outside' follows after this function

References size(), and std::vector< typename _Tp, typename _Alloc >::size().

ComputeIsosurface()

gridop_API Grid & Fiber::ComputeIsosurface	(	double	Isolevel,
		const Ageable &	Trigger,
		const Grid &	RegularGrid,
		const string &	fieldname,
		Slice &	TimeStep,
		const string &	isosurfacename,
		double	precision
	)

Compute an isosurface as a new Grid object from a scalar field given on a regular grid.

Parameters

TimeStep	The Slice where the new Grid is supposed to reside, which usually will be the same Slice as where the original RegularGrid will be, but it doesn't need to be there.
isosurfacename	The name of the new isosurface grid, as to be created in the provided time slice

References ComputeIsosurface(), and Fiber::Representation::Positions().

Referenced by ComputeIsosurface(), and renderVolume().

createPersistentRegularlyPositionFragments()

bool Fiber::createPersistentRegularlyPositionFragments	(	const RefPtr< RegularlyFragmentedField< 3 > > &	positions,
		const std::list< std::pair< MultiIndex< 3 >, RefPtr< UniformCartesianArray > > > &	frags
	)

Function to create regularly fragmented positions from a specifiyed list of RefPtr<UniformCartesianArray>s.

RefPtr<BoundingBox> bb; 
        bb = getBoundingBox( *vertex_grid ); 
 
pair< RefPtr< RegularlyFragmentedField<3> >, RefPtr<Grid> > reg_grid = PrepareRegularlyFragmentedPositions( bundle_btr, time, grid_name, *bb, nr_frags ); 
 
list<pair<MultiIndex<3>, RefPtr<UniformCartesianArray> > > regular_fragments;
 
MultiIndex<3> nr_frags, frag, dims; 
        nr_frag = 10, 10, 10; 
        dims    = 32, 32, 32;
        frag    = 0,0,0;
 
        do
        {
        tvector frag_len = (bb->maxcoord() - bb->mincoord()).multiply( 1.0/nr_frags[0], 1.0/nr_frags[1], 1.0/nr_frags[2]); 
                regular_fragments.push_back(pair<MultiIndex<3>, RefPtr<UniformCartesianArray> >(frag, new UniformCartesianArray( dims, min, frag_len.multiply( 1./(dims[0]-1),1./(dims[1]-1), 1./(dims[2]-1) ) ) ) );
        } while( frag.inc(nr_frags) )  ; 
 
         CreatePersistentRegularlyPositionFragments( reg_grid.first, regular_fragments);

Author

marcel

Returns

false if the FragmentID cannot be found via the MultiIndex<3>

References std::cout, and std::endl().

createTexture3D()

RefPtr< Wizt::GLTexture3D > Fiber::createTexture3D	(	const RefPtr< MemBase > &	Data,
		const type_info &	TextureType,
		const Wizt::Range &	R,
		const MultiIndex< 3 > &	Start,
		const MultiIndex< 3 > &	End,
		const MultiIndex< 3 > &	Step,
		int	TextureUnit,
		GLenum	format,
		GLenum	internalformat,
		int	BitsPerTexel,
		double	Gamma
	)

Load data from a memory array to a 3D OpenGL texture, purely procedural version.

Parameters

BitsPerTexel

The bits used by open GL for its texture storage, accordint to the internalformat parameter. It is usually associated via the GL::glMemSize<> type trait, but that only gives an upper limit for compressed textures.

Referenced by createTexture3D(), and Fiber::CreateTexture< TextureStorageType, TextureFormat >::Volume().

createTree()

template<int N, class T , class C >

MemCore::RefPtr< Eagle::KDTree< N, T > > Fiber::createTree	(	const C &	coordinates,
		const unsigned	size
	)

create a KDTree

do not parallelize this for-loop because corrupt output occurs
 

References size().

DEPRECATED() [1/2]

gridop_API RefPtr< Grid > Fiber::DEPRECATED ( "Use grid/types/RegularGrid3D.hpp:UniformGrid3D instead"  , createUniformGrid(const string &InputGridname, const Info< Skeleton > &Level, const string &OutputGridname, const MultiIndex< 3 > &Resolution, const RefPtr< Eagle::BoundingBox > &SubBox=NullPtr())    )

extern

Create a uniform Grid from a given Grid.

Application code might want to check if a Grid already exists under the given OutputGridname, since otherwise it will be overwritten here. Code to check the existence of some Grid on a given Slice is like this:

const RefPtr<Slice>&TheInputGridTimeSlice = Level.getSlice(); 
        if (TheInputGridTimeSlice->findGrid( OutputGridname ) )
        {
                grid exists
        }

Note

This function will establish a parent-child relationship between the input Grid and the output Grid. The resulting Grid will be inserted into the same Slice as the input Grid.

Returns

The newly created Grid. It is inserted in the Slice of the input Grid, so it is safe to ignore the return value, but it can be checked for validity to verify the correctness of the function call.

DEPRECATED() [2/2]

gridop_API RefPtr< Grid > Fiber::DEPRECATED ( "Use grid/types/RegularlyFragmentedGrid.hpp: instead"  , prepareRegularlyFragmentedGrid(BundlePtr bp, double time, const string &grid_name, int grid_dimensionality, const RefPtr< RegularlyFragmentedField< 3 > > &positions, const Eagle::BoundingBox &bb)    )

extern

Prepare a uniform regularly fragmented uniform grid from a given bounding box and number of fragments.

Each fragment has to be created using a RefPtr<UniformCartesianArray>.

Author

marcel

Todo:

Check for already existent grid.

Returns

The newly created Grid. And the position field.

EvalFieldOnRepresentation()

gridop_API RefPtr< Field > Fiber::EvalFieldOnRepresentation	(	Representation &	DstRep,
		const RefPtr< Skeleton > &	DestVertices,
		Grid &	SourceGrid,
		const string &	fieldname,
		Slice &	DestGridSlice,
		const string &	HelperDestGridName,
		bool	StoreResult = true
	)

Evaluate a Field given on some source Grid on a specific Representation.

Parameters

DestVertices

If we have a relative representation here, if so, it would contain interpolation weights for each vertex from each source vertex. If none such is found, can still have interpolation weights from another representation, such as from the edges of the source grid into the destination grid. This is the case for instance for isosurfaces, where the vertices of the destination grid reside exactly on the edges of the source grid.

References Fiber::SkeletonMap::findVertices(), Fiber::Grid::makeChart(), and pullData().

Referenced by EvalGrid(), Wizt::BinaryFieldOperatorObject< TheBinaryOperator, NamingOperator, PrimaryValueType, SecondaryValueType, ResultValueType >::FieldOperation(), Wizt::Fish< Fiber::Field >::getFieldRepresentation(), and Wizt::VertexFieldCollection::retrieveFields().

EvalGrid()

gridop_API RefPtr< Field > Fiber::EvalGrid	(	Grid &	DestGrid,
		Grid &	SourceGrid,
		const string &	fieldname,
		Slice &	DestGridSlice,
		const string &	HelperDestGridName,
		bool	StoreResult
	)

Example: SourceGrid ....

Given a field F on the SourceGrid, compute its values on the DestGrid (if possible).

uniform grid DestGrid ...... a surface, or 2D slice, or arbitrary slice

Parameters

DestGridSlice	Slice of the destination grid, the place where to store a helper Grid. It may be a temporary one that is not part of a Bundle if this helper Grid should not be permanently stored. This Slice is also used to find lookup information about the current Grid object, for instance interpolation values from curvilinear to uniform coordinates.
DestGridName	Name of the destination grid in the destination slice, used to build an internal helper grid on the same slice.
StoreResult	Flag to tell if the field shall be stored on the destination Grid (and thus be re-used on the next call), or just returned as a temporary.

Returns

The newly computed field on the destination grid, which is also stored on the destination grid.

References EvalFieldOnRepresentation().

ExecuteExpression()

Anfortas_API RefPtr< Field > Fiber::ExecuteExpression	(	Representation &	R,
		istream &	inputstream
	)

Set all fields of a Representation as a Variable If an expression refers to a non-existing Field, then it will be treated by the parser as an identifier, but not a variable, leading most likely to a syntax error.

References apply(), Fiber::FiberMap< ID >::findMostFragmentedField(), Fiber::Representation::iterate(), and MemCore::Typename().

ExpandBBox()

bool Fiber::ExpandBBox	(	RefPtr< BoundingBox > &	BBox,
		CreativeArrayBase &	CAB,
		DataCreationMode	theDataCreationMode = AlwaysCreate
	)

Expand a given bounding box by the given data array.

Parameters

BBox	If the bounding box is null pointer, it will be assigned with the properties of the coordinate array, otherwise it will be expanded.
CAB	A creator for the data array, might be procedural or explicitely stored.
DataCreationMode	Under which conditions to create data: 0 - always create data and scan when if needed 1 - compute bounding box only when data exists in memory, otherwise request them for a subsequent call and return false for now 2 - compute bounding box only when data exists in memory, otherwise don't even request them.

Returns

true if the Bounding box could be expanded, false if the coordinate array was inaccessible, e.g. non existent or incompatible data type.

References MemCore::Intercube::addInterface(), ComputeOnlyIfAvailable, ComputeOrRequest, MemCore::CreatorBase< class Domain >::create(), MemCore::CreatorBase< class Domain >::get(), MemCore::Attributes::getAttribute(), MemCore::CreatorBase< class Domain >::request(), MemCore::ReferenceBase< class Object >::self(), and std::exception::what().

Referenced by Wizt::GridAnemoneRenderObject::getModifiedBBox().

fillVertexSelection()

gridop_API void Fiber::fillVertexSelection	(	RefPtr< Grid > &	grid,
		RefPtr< MemArray< 1, VertexSelection_t > > &	selection
	)

Fill vertex selection by selecting all points inside the convex hull (3D) of the selection.

2D also interesting? Alpha shape thingy also interesting?

Todo:

: - implement

• this should be done better in 2D screen space, knowing the polygon and the camera matrix for transforming points.

References fillVertexSelection().

Referenced by fillVertexSelection().

findNClosestPoints()

template<size_t N>

size_t Fiber::findNClosestPoints	(	const Eagle::point3 &	QueryPoint,
		const nanoflannKDTree &	theTree,
		std::array< uint32_t, N > &	indices,
		std::array< double, N > &	squared_distances
	)

Returns

The number of points found.

GenerateTriangularSurfaceFromPoints()

fiberbaseopQ_API TriangularSurface Fiber::GenerateTriangularSurfaceFromPoints ( Grid &  OutputGrid, const RefPtr< MemArray< 1, Eagle::PhysicalSpace::point > > &  InputVertices, const double  edge2D_max  )

extern

interface to http://qhull.org/ version qhull-2015.2

get connectivity as TriangularSurface

GetCartesianPositions()

MemCore::RefPtr< Field > Fiber::GetCartesianPositions ( MemCore::RefPtr< Grid >  grid )

inline

Extract a Field with skeleton(0,0) and Cartesian3D coordinates named "Position" from the base space from a given grid.

Deprecated:

getFieldRange() [1/2]

RefPtr< DataRangeBase > Fiber::getFieldRange ( Field &  F, bool  AsynchRequest = false, bool  theAvoidDataLoading = false  )

inline

Determine and eventually compute the numerical range of a field.

This operation is performed component-wise, the result will be stored in a DataRange<> object. Application code needs to type cast.

References getFieldRange().

getFieldRange() [2/2]

RefPtr< DataRangeBase > Fiber::getFieldRange ( Field &  F, std::string &  ErrorMessage, bool  AsynchRequest = false, bool  theAvoidDataLoading = false  )

inline

Determine and eventually compute the numerical range of a field.

This operation is performed component-wise, the result will be stored in a DataRange<> object. Application code needs to type cast.

References getFieldRange_internal().

Referenced by Wizt::ShaderFields::addField(), and getFieldRange().

getFieldRange_internal()

fiberop_API RefPtr< DataRangeBase > Fiber::getFieldRange_internal	(	Field &	F,
		string &	ErrorMessage,
		bool	AsynchRequest,
		bool	theAvoidDataLoading
	)

TODO: Go via a type registry.

}

References getTypedFieldRange(), and MemCore::Typename().

Referenced by getFieldRange(), and getQuickFieldRange().

getFragmentRange() [1/2]

RefPtr< DataRangeBase > Fiber::getFragmentRange	(	CreativeArrayBase &	CAB,
		bool	AsynchRequest = false,
		bool	theAvoidDataLoading = false,
		const RefPtr< MemBase > &	PossibleData = nullptr
	)

TODO: Go via a type registry.

Determine and eventually compute the numerical range of a field fragment.

This operation is performed component-wise, the result will be stored in a DataRange<> object. Application code needs to type cast.

This code is identical to calling

if (RefPtr<DataRangeBase> DR =
    getTypedFragmentRange<int, double, float,
                             uint8_t, uint16_t, uint32_t, uint64_t,
                             int8_t,  int16_t,  int32_t,  int64_t >(F, f, AsynchRequest, theAvoidDataLoading) )
   return DR;

Parameters

CAB	The creator managing the data and holding related attributes
PossibleData	If data from the CAB have already been loaded, they can be provided here. They must be identical to CAB.create() or the behavior will become weird, undefined, terrible, catastrophic...

References getTypedFragmentRange().

Referenced by getFragmentRange().

getFragmentRange() [2/2]

RefPtr< DataRangeBase > Fiber::getFragmentRange ( Field &  F, const RefPtr< FragmentID > &  f, bool  AsynchRequest = false, bool  theAvoidDataLoading = false, const RefPtr< MemBase > &  PossibleData = nullptr  )

inline

Determine and eventually compute the numerical range of a field fragment.

This operation is performed component-wise, the result will be stored in a DataRange<> object. Application code needs to type cast.

This code is identical to calling

if (RefPtr<DataRangeBase> DR =
    getTypedFragmentRange<int, double, float,
                             uint8_t, uint16_t, uint32_t, uint64_t,
                             int8_t,  int16_t,  int32_t,  int64_t >(CAB, AsynchRequest, theAvoidDataLoading) )
   return DR;

References getFragmentRange().

GetFragments()

MemCore::RefPtr< Field > Fiber::GetFragments ( MemCore::RefPtr< Grid >  grid )

inline

Extract the field containing the names of all fields from given grid.

Thus extract the representation "Positions" mapping skeleton(3,2) As skeleton(0,0).

GetFragmentsBBs()

MemCore::RefPtr< Field > Fiber::GetFragmentsBBs ( MemCore::RefPtr< Grid >  grid )

inline

Extract the field containing the Bounding Boxes of the fragments of a given grid.

Thus extract representataion "Position" a mapping skeleton(3,2) as CartesianChart3D.

getQuickFieldRange()

RefPtr< DataRangeBase > Fiber::getQuickFieldRange ( Field &  F, std::string &  ErrorMessage, bool  AsynchRequest = false  )

inline

Determine and eventually compute the numerical range of a field without loading data, i.e.

only on data available in RAM.

References getFieldRange_internal().

getSkeletonFields()

gridop_API getSkeletonFieldsResults_t Fiber::getSkeletonFields	(	const RefPtr< Fiber::Skeleton > &	DestVertexSkeleton,
		const RefPtr< Fiber::Chart > &	chart,
		const FieldSelector &	FS,
		const string &	ImplicitFieldName = string()
	)

Parameters

DestVertexSkeleton	We want a field on this Skeleton.
FS	The field selector describing the field that we look for.
chart	We want the field in this chart.
ImplicitFieldName	The name of a field that may be given on the grid and is used instead of a valid FieldSelector if a grid is defined.

getTangentialVectors()

gridop_API RefPtr< MemArray< 1, Eagle::tvector3 > > Fiber::getTangentialVectors	(	Grid &	G,
		const string &	FieldName = TangentialVectorFieldName
	)

Compute tangential vectors in a grid object, which has a set of lines defined.

Todo:

Make use of timestamps of the involved fields

Define an exception class here to indicate the many reasons of failures here, instead of just returning a NullPtr.

References ComputeTangentialVectors(), Fiber::Grid::getCartesianRepresentation(), and TangentialVectorFieldName.

getTypedFieldRange()

template<typename... Type>

RefPtr< DataRangeBase > Fiber::getTypedFieldRange ( Field &  F, bool  AsynchRequest, bool  theAvoidDataLoading  )

inline

Get the range of a field by iterating over a list of types.

The global function getFieldRange() uses this function to compute the range of native C++ types, but this function needs to be used if user-defined types shall also be included in a generic range computation.

Usage:

if (RefPtr<DataRangeBase> DR =
    getTypedFragmentRange<int, double, float,
                             uint8_t, uint16_t, uint32_t, uint64_t,
                             int8_t,  int16_t,  int32_t,  int64_t >(F, f, AsynchRequest, theAvoidDataLoading) )
   return DR;

References Fiber::DataRange< Type >::retrieve().

Referenced by getFieldRange_internal().

getTypedFragmentRange()

template<typename... Type>

RefPtr< DataRangeBase > Fiber::getTypedFragmentRange ( Field &  F, const RefPtr< FragmentID > &  fragmentID, bool  AsynchRequest, bool  theAvoidDataLoading, const RefPtr< MemBase > &  PossibleData = nullptr  )

inline

Get the range of a field fragment by iterating over a list of types.

The global function getFragmentRange() uses this function to compute the range of native C++ types, but this function needs to be used if user-defined types shall also be included in a generic range computation.

References Fiber::DataRange< Type >::retrieve().

GetUniGridMappers()

MemCore::RefPtr< Field > Fiber::GetUniGridMappers ( MemCore::RefPtr< Slice >  slice, MemCore::RefPtr< Grid >  source_grid  )

inline

Extract the fragmented field storing the UniGridMappers.

They are stored in a different grid as the source. A Grid named 'UniMappers'. Extract a representation fragments(from source grid) as unigridmaps(from grid:'UniMappers'), skeleton(3,2) as skeleton(3,1)

growVertexSelection()

gridop_API void Fiber::growVertexSelection ( MemCore::RefPtr< Fiber::Grid > &  grid, MemCore::RefPtr< Fiber::MemArray< 1, VertexSelection_t > > &  selection, double  radius  )

extern

Grows a vertex selection by a given radius.

This is implemented as a simple and slow method, doing a kd tree query for each selection point to increase the set of selection points.

Todo:

: split up in 2 functions: - fill the selection by selecting all points inside the convex hull of the selection

• grow selection by using the convex hull
  

iniTIFF()

template<typename T >

T Fiber::iniTIFF	(	TIFF *	OutTIFF,
		const MultiIndex< 3 > &	FragDims,
		const tvector &	CellSize
	)

TILES INFO

InterpolateUniformHeight()

gridop_API void Fiber::InterpolateUniformHeight	(	MemCore::TypedChunkBase< FixedArray< double, 3 > > &	Dest,
		const UniformCartesianArray &	UMap,
		const MultiArray< 3, double > &	Heightfield,
		int	Component = 2,
		const FixedArray< double, 3 > &	Numericalshift = {0., 0., 0.},
		double	HeightSlice = 0.0
	)

Given an array of points (derived from FixedArray<double> ), replace the given component by an interpolated value from the given height field placed on the uniform array.

Parameters

UMap	The uniform cartesian array
Heighfield	Some scalar field given on the same index space as UMap

InterpolateUniformHeightfield()

gridop_API void Fiber::InterpolateUniformHeightfield ( MemCore::TypedChunkBase< FixedArray< double, 3 > > &  Dest, const std::vector< size_t > &  IndexArray, const UniformCartesianArray &  UMap, const MultiArray< 3, double > &  Heightfield, int  Component = 2, const FixedArray< double, 3 > &  Numericalshift = {0., 0., 0.}, double  HeightSlice = 0.0  )

extern

Given an indexed array of points (derived from FixedArray<double> ), replace the given component by an interpolated value from the given height field placed on the uniform array.

This function can be used if only some points of the Destination array overlap with the given uniform cartesian array and its height map. For instance, this is the case if the data are retrieved from the fragments of a fragmented uniform cartesian grid.

Parameters

UMap	The uniform cartesian array
Heighfield	Some scalar field given on the same index space as UMap

IOinit()

int Fiber::IOinit ( )

inline

Initialize I/O layers for pre-defined template instantiations.

Currently implemented I/O layers are XML (output only) and HDF5. This function needs to be called by the main() functions or anywhere before loading or saving a file from the Bundle hierarchy. The most common data and array types are predefined and instantiated in the libraries which come with the FiberIO layer, but arbitrary user types can be added by application code. See the respective I/O layers for details.

References FiberIOHDF5init().

isPartialDerivable()

gridop_API bool Fiber::isPartialDerivable

(

const RefPtr< CreativeArrayBase > &

CAB

)

Check if the partial derivative can be computed from the given data.

Not all types and ranks are currently supported. This function will not create or load any data.

References begin(), and isPartialDerivable().

Referenced by isPartialDerivable(), and PartialDerivative().

loadFieldSize()

RefPtr< SizeInterface > Fiber::loadFieldSize

(

F5Path *

field

)

Get a field's size without loading any data.

Calls F5Tget_space();

Referenced by UniformField().

log2()

constexpr int Fiber::log2 ( index_t  arg )

inlineconstexpr

Compute the logarithm to the basis of two from the given index.

Actually, should rather consider some of the versions from http://graphics.stanford.edu/~seander/bithacks.html

References std::arg().

MapToUniform() [1/2]

gridop_API RefPtr< MemArray< 3, double > > Fiber::MapToUniform ( const UniformCartesianArray &  UMap, const MemCore::TypedChunkBase< FixedArray< double, 3 > > &  , double  InvalidData, int  Component = 2, const FixedArray< double, 3 > &  Numericalshift = {0., 0., 0.}  )

extern

Create a height field.

Parameters

InvalidData

Numerical value to fill points that are not in the input data array.

MapToUniform() [2/2]

gridop_API void Fiber::MapToUniform	(	MultiArray< 3, double > &	Heightfield,
		const UniformCartesianArray &	UMap,
		const MemCore::TypedChunkBase< FixedArray< double, 3 > > &	,
		std::vector< index_t > &	IndexArray,
		int	Component = 2,
		const FixedArray< double, 3 > &	Numericalshift = {0., 0., 0.}
	)

Insert data to a height field.

@params IndexArray Optional array containing the index mapping from source to destination on return.

References size().

Referenced by MapToUniformIndex().

MapToUniformIndex()

gridop_API MapToUniformIndexResult_t Fiber::MapToUniformIndex	(	const UniformCartesianArray &	UMap,
		MemCore::TypedChunkBase< FixedArray< double, 3 > > &	Src,
		double	InvalidData,
		int	Component,
		const FixedArray< double, 3 > &	NumericalShift
	)

Create a height field with an index array that allows to reproduce the mapping on other data arrays.

An application may look similar to this:

#include <field/CreateIndirectionArray.hpp>
 
 
UniformCartesianArray&UMap;
TypedChunkBase<FixedArray<double,3>>&Points;
 
const auto&R = MapToUniformIndex(UMap, Points, 0.0/0.0);
 
        for(all fields)
        {
        const RefPtr<MemBase>&Src = ...;
 
        RefPtr<MemBase> Dst = CreateIndirection(Src, R.second);
 
                ... do something with Dst ...
        }

Parameters

InvalidData

Numerical value to fill points that are not in the input data array.

References MapToUniform().

operator+()

RefPtr< SizeInterface > Fiber::operator+	(	const RefPtr< SizeInterface > &	L,
		const RefPtr< SizeInterface > &	R
	)

Returns

Will return a NullPtr() if the dimensions don't match.

PartialDerivative() [1/2]

gridop_API RefPtr< CreativeArrayBase > Fiber::PartialDerivative	(	const RefPtr< CreativeArrayBase > &	CAB,
		string &	FailureDescription,
		const RefPtr< MemCore::Cache > &	Cache
	)

instead, use an ondemand creator here!!!!!!!!!!!

References isPartialDerivable().

PartialDerivative() [2/2]

gridop_API RefPtr< Field > Fiber::PartialDerivative	(	Field &	F,
		const string &	GradientFieldname,
		Representation &	CurrentRepresentation,
		Representation &	FieldIDSource,
		string &	FailureDescription,
		const RefPtr< MemCore::Cache > &	Cache = MemCore::Cache::MemCache()
	)

Compute a Field that is the partial derivative of the given field in the specified representation.

The derivative will be inserted into the representation under the given name.

Parameters

F	The field that should be partially derived.
NewFieldname	The name of the newly created field as it will be inserted into the CurrentRepresentation
CurrentRepresentation	The current representation.
FieldIDSource	The representation that will be used to share field identifiers.

Returns

The newly created field, which is also available through the current represention. The return value will be NullPtr if the partial derivative could not be computed.

References apply(), and Fiber::Representation::createSharedFieldID().

Polygonize()

template<class ArrayType >

int Fiber::Polygonize ( std::vector< index_t > &  IsoVertexEdge, std::vector< double > &  IsoVertexWeight, std::vector< TriangleCell > &  IsoSurfaceTriangles, map< index_t, index_t > &  IsosurfaceVerticesAsEdges, const FieldExplorer< ArrayType > &  FE, const MultiIndex< 3 > &  CellIndex, double  precision, index_t  EdgeOffset = 0  )

inline

Create polygons out of a given field to be explored, based on the algorithm described by http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/.

Parameters

FE	The field to be explored

References Fiber::MultiIndex< Dims >::BitIndex(), ComputeInterpolationEdgeAndWeight(), std::vector< typename _Tp, typename _Alloc >::push_back(), and std::vector< typename _Tp, typename _Alloc >::size().

renderVolume()

int Fiber::renderVolume	(	Wizt::VRenderContext &	Context,
		int	slices,
		const Eagle::FixedArray< double, 3 > &	TS,
		const Eagle::FixedArray< double, 3 > &	TOffset,
		const Eagle::point3 &	Observer,
		const Eagle::point3 &	BBoxMin,
		const Eagle::point3 &	BBoxMax,
		int	CancellationCheck = 0xFF,
		double	CutDistance = -1,
		bool	CutInFrontOfCutDistance = true
	)

TODO: Establish caching here via view point/observer direction and VBO's.

Render a box via a sequence of view-orthogonal cut planes, starting from the back progressing to the front.

Todo:

enhance by giving cut plane distance limits

Parameters

TS	Texturescale - allows to multiply texture coordinates by this factor
TOffset	Texture offset - allows to shift texture coordinates by this amount

Returns

The number of slices actually drawn. The drawing of slices may be cut short by the isCancelled() function as implemented in the VRenderContext object.

References ComputeIsosurface(), std::pair< typename _T1, typename _T2 >::first, Eagle::norm(), std::pair< typename _T1, typename _T2 >::second, and size().

Referenced by Wizt::Vitreous::FragmentRenderer::apply().

rescale()

gridop_API RefPtr< MemBase > Fiber::rescale	(	double	scale,
		const RefPtr< MemBase > &	Data,
		const MemBase::Creator_t &	Crec = NullPtr()
	)

Parameters

FieldIDSource

An optional Representantation that already carries some field identifier that is to be shared for the newly generated field.

RoundUpToNextHighestPowerOf2()

constexpr index_t Fiber::RoundUpToNextHighestPowerOf2 ( index_t  v )

inlineconstexpr

Align a value to the next fitting power of 2.

From: http://graphics.stanford.edu/~seander/bithacks.html

setupAnalyticIntegrators()

template<class LineIntegratorAnalyticContainer >

bool Fiber::setupAnalyticIntegrators	(	LineIntegratorAnalyticContainer &	AnalyticLineIntegrators,
		const RefPtr< Field > &	ToIntegrateField,
		double	Time
	)

Initialize a container of analytic line integrators with analytic functions as retrieved from a Field object.

Parameters

LineIntegratorAnalyticContainer	A container type for analytical line integrators, for instance std::vector<LineIntegratorAnalytic>
AnalyticLineIntegrators	The container which contains the actual integrator objects. It must already be of the right size().

Returns

false if the Field does not provide an Eagle::AnalyticFunctionBase Interface.

UniformField()

RefPtr< Field > Fiber::UniformField	(	F5Path *	field,
		const RefPtr< FragmentIDCollection > &	theFragmentIDCollection,
		const RefPtr< LoaderProgress > &	TheLoaderProgressor
	)

F5Fget_range(field, &min, &max, F5T_COORD3_FLOAT) )

References loadFieldSize().

Variable Documentation

CurveParameterFieldName

gridop_API const char Fiber::CurveParameterFieldName = "length"

A default name for the field that holds the respective values of a curve parameter.

It will just be "length";

DontUseCreatorRangeAttributeAsBoundingBoxDefault

bool Fiber::DontUseCreatorRangeAttributeAsBoundingBoxDefault

Initial value:

= MemCore::getEnvInteger("DontUseCreatorRangeAttributeAsBoundingBoxDefault",
"Do not use the range attribute on data creators as default value for bounding boxes.\n"
"On the command line (sh/bash/ksh), do\n"
" export DontUseCreatorRangeAttributeAsBoundingBoxDefault=1\n"
"to disable using the range attribute. "
"This will slow down operations but may help to trace down issues due to wrongly specified ranges.\n"
)

TangentialVectorFieldName

gridop_API const char Fiber::TangentialVectorFieldName = "Tangents"

A default name for the field that holds the tangential vectors of a grid describing lines.

It will just be "Tangents";

Referenced by getTangentialVectors().