FiberVISH  0.2
Fish-TheFiberBundleAPIfortheVishVisualizationShell
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
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

 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, NEXT > >
 
struct  AcceptType< META::NIL >
 
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...
 
class  Attributes
 Attributes are a selection of named MemCore::ChunkBase objects, each of them may carry arbitrary data. 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...
 
class  BBoxExpander
 ingroup BaseOp A field fragment iterator that computes or expand a bounding box. 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  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  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<-1 >
 Stop the recursion of computing the partial derivatives over all dimensions. More...
 
struct  ComputeUnitVector
 
struct  ComputeVertexNormals
 
struct  const_ranged_for_iterator
 
class  ConstSkeletonIterator
 Base class for constant iterators over a sequence of skeletons. More...
 
singleton  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  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
 light-weight An object with neglible overhead when copying. More...
 
struct  DirectProductMemArrayCreateBaseArray
 
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...
 
class  Field
 A Field is a collection of CreativeArrayBase 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...
 
struct  FieldRange
 
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...
 
class  FixedArrayTrait
 
class  FixedArrayTrait< T, 1 >
 
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  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  FragmentIndexIterator
 
struct  FragmentIsoSurfacer
 
class  FragmentIterator
 Base class for iterators over the fragments of a field. More...
 
class  FragmentLocation
 
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
 
singleton  FSLoader
 
class  FSLoader< Bundle >
 
struct  fsRepresentationSaver
 
singleton  FSSaver
 
class  FSSaver< Bundle >
 
class  FSSaver< MemArrayBase >
 
class  FSSaver< MemArrayStorage< N, T, Storage > >
 
class  FSSaver< MemArrayStorage< N, T, vector< T > > >
 
singleton  FSSaverCreator
 
class  FSSaverCreator< Bundle >
 
class  FSSaverCreator< MemArrayStorage< N, T, Storage > >
 
struct  fsSkeletonSaver
 
struct  fsSliceSaver
 
struct  FTless
 
class  FunctionalCreator
 
class  FunctionalCreatorBase
 
struct  GammaRemap
 
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  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
 Move this into StorageTransformation More...
 
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  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
 
singleton  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 >
 
singleton  HDF5SaverCreator
 
class  HDF5SaverCreator< MemArrayStorage< N, T, Storage > >
 
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...
 
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  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...
 
class  JPGCreator
 Class describing a JPEG image file. 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
 light-weight An object with neglible overhead when copying. More...
 
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
 
singleton  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
 
struct  MultiArray
 A multidimensional array for data that are stored via a native, writable C++ pointer. More...
 
class  MultiArray< 0, T >
 
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  myHDF5Loader
 
class  NearestNeighborIpol
 Nearest-Neighbor interpolation, just fast and wrong. More...
 
class  NoDelimiter
 
struct  NOT
 Inverting a bundle property. More...
 
struct  NotDoebyShapefile
 
singleton  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  PointSearch
 Point Search Utility functions for finding points in a grid based on provided coordinate information. More...
 
struct  PolynomialCoordinateAxisArray
 
struct  Power2Alignment
 
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  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
 
struct  RemoveFlawEchoesParameters
 
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
 
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  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
 
struct  SizeOf< void >
 
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
 
singleton  TextureChart
 
class  TextureChart< 2 >
 Chart object for 2D texture coordinates. More...
 
class  TGACreator
 Class describing a TARGA image file. 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...
 
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  TypeAction
 TypeActions are objects that are stored in a registry associated with each type that can be used to build MemArrays from. 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  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
 
singleton  XMLLoader
 
class  XMLLoader< Bundle >
 
singleton  XMLSaver
 
class  XMLSaver< Bundle >
 
class  XMLSaver< MemArrayBase >
 
class  XMLSaver< MemArrayStorage< N, T, Storage > >
 
class  XMLSaver< MemArrayStorage< N, T, vector< T > > >
 
singleton  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
 
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< 2, rgb > Image_t
 
typedef LIST< float, LIST
< double, LIST< int, LIST
< int32_t, LIST< uint8_t,LIST
< uint16_t, LIST< uint32_t > > > > > > > 
RangeInputTypes
 
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,LIST< rgb_t >>
 
using RGBAColorTypes = LIST< rgba16_t, LIST< rgba_t >>
 
using IntegerHDRColorTypes = LIST< rgba16_t, LIST< rgb16_t >>
 
using HDRColorTypes = LIST< rgb_float_t, LIST< rgba_float_t, LIST< rgba16_t, LIST< rgb16_t >>>>
 
using IntegerColorTypes = LIST< rgb16_t, LIST< rgba16_t, LIST< rgba_t, LIST< rgb_t >>>>
 
using ColorTypes = LIST< rgb_float_t, LIST< rgba_float_t, LIST< rgb16_t, LIST< rgba16_t, LIST< rgba_t, LIST< rgb_t >>>>>>
 
using IntegerPixelTypes = LIST< rgb16_t, LIST< rgba16_t, LIST< rgba_t, LIST< rgb_t, LIST< unsigned char, LIST< unsigned short >>>>>>
 
using PixelTypes = LIST< rgb16_t, LIST< rgba16_t, LIST< rgba_t, LIST< rgb_t, LIST< unsigned char, LIST< unsigned short, LIST< rgb_float_t, LIST< rgba_float_t, LIST< float >>>>>>>>>
 
using FloatPixelTypes = LIST< rgb_float_t, LIST< rgba_float_t, LIST< 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 std::map< const
WeakPtr< FiberTypeBase >
, RefPtr< TypeAction >, FTless
FiberTypeRegistry_t
 
typedef std::map< int,
FiberTypeRegistry_t > 
MultiTypeRegistry_t
 
typedef typemap
< MultiTypeRegistry_t > 
TypeRegistry_t
 
typedef TypeList TypeList_t
 
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
 
typedef FragmentIterator FieldFragmentIterator
 
typedef MemCore::WeakPtr
< CreativeArrayBase,
MemCore::Creature
WeakPtrCreativeArrayBase_t
 
template<class OwnedObjectType >
using OwnerOf = typename Ownable< OwnedObjectType >::Container
 Shortcut to find the owning type.
 
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< ChartIDChartIdentifier
 
typedef std::pair< SkeletonID,
RefPtr< Skeleton > > 
SkeletonInfo
 
typedef WeakPtr< BaseSpaceRepresenter
 The type used to reference other objects, which is the anchor of representations of a Skeleton. More...
 
typedef WeakPtr
< Representation, typename
BaseSpaceDependency::reference_domain_t > 
WeakPtrRepresentation_t
 
typedef RefPtr< Representation,
typename
BaseSpaceDependency::reference_domain_t > 
RefPtrRepresentation_t
 
typedef Skeleton Topology
 
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. More...
 
typedef Eagle::Mult Mult
 
typedef Eagle::Div Div
 
typedef Eagle::Add Add
 
typedef Eagle::Sub Sub
 
typedef RangeFailureAction
< FIBER_VECTOR_RANGE_FAILURE_ACTION > 
DefaultRangeFailureAction
 
typedef MemArray
< 3, Eagle::tvector3 > 
VectorArray_t
 
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  FragmentProperty { Undefined = 0, Offset = 1, OverlapStart = 2, OverlapEnd = 3 }
 Predefined multidimensional properties on fragments.
 
enum  { FEM_VERTS =0, FEM_CELLS }
 

Functions

RefPtr< FieldExecuteExpression (Representation &R, istream &inputstream)
 
Anfortas_API RefPtr< FieldExecuteExpression (Representation &R, std::istream &inputstream)
 
RefPtr< RepresentationGetUniqueCartesianRepresentation (const RefPtr< Grid > &grid)
 
MemCore::RefPtr< FieldGetCartesianPositions (MemCore::RefPtr< Grid > grid)
 Extract a Field with skeleton(0,0) and Cartesian3D coordinates named "Position" from the base space from a given grid. More...
 
MemCore::RefPtr< FieldGetFragments (MemCore::RefPtr< Grid > grid)
 Extract the field containing the names of all fields from given grid. More...
 
MemCore::RefPtr< FieldGetFragmentsBBs (MemCore::RefPtr< Grid > grid)
 Extract the field containing the Bounding Boxes of the fragments of a given grid. More...
 
MemCore::RefPtr< FieldGetUniGridMappers (MemCore::RefPtr< Slice > slice, MemCore::RefPtr< Grid > source_grid)
 Extract the fragmented field storing the UniGridMappers. More...
 
RefPtr< FieldcreateColorFieldOnPoints (const RefPtr< Grid > &grid, const string fieldname)
 
RefPtr< FieldgetColorFieldOnPoints (const RefPtr< Grid > &grid, const string fieldname)
 
gridop_API MemCore::RefPtr< FieldcreateColorFieldOnPoints (const MemCore::RefPtr< Grid > &grid, const string fieldname=FIBER_COLOR_FIELD)
 
gridop_API MemCore::RefPtr< FieldgetColorFieldOnPoints (const MemCore::RefPtr< Grid > &grid, const string fieldname=FIBER_COLOR_FIELD)
 
RefPtr< FieldEvalGrid (Grid &DestGrid, Grid &SourceGrid, const string &fieldname, Slice &DestGridSlice, const string &HelperDestGridName, bool StoreResult)
 Example: SourceGrid .... More...
 
RefPtr< FieldEvalFieldOnRepresentation (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 Fiber::Info< Fiber::Grid > &DestinationGrid, const string &ImplicitFieldName=string())
 
RefPtr< BoundingBoxComputeBBox (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. More...
 
RefPtr< BoundingBoxgetFragmentBBox (const RefPtr< FragmentID > &fid, const RefPtr< CreativeArrayBase > &FragmentDataCreator, const Field &Coords)
 
RefPtr< BoundingBoxgetBoundingBox (Field &Coords)
 
RefPtr< BoundingBoxgetBoundingBox (const RefPtr< Field > &Coords)
 
RefPtr< BoundingBoxgetBoundingBox (const RefPtr< Representation > &Vertices)
 
RefPtr< BoundingBoxgetBoundingBox (const RefPtr< Skeleton > &Vertices, const RefPtr< Fiber::Chart > &chart)
 
RefPtr< BoundingBoxgetBoundingBox (const Grid &G, const RefPtr< Fiber::Chart > &chart)
 
bool expandBoundingBox (const RefPtr< Field > &Coords, RefPtr< BoundingBox > &theBox)
 
bool expandBoundingBox (RefPtr< BoundingBox > &theBox, const RefPtr< Field > &Coords)
 
template<int N>
RefPtr< BoundingBoxgetBoundingBox (const RefPtr< RegularlyFragmentedField< N >> &Coords)
 
RefPtr< GridExtractTrajectories (Bundle &B, const string &SelectedGridName, double StartTime, double ComaLength, const string &TrajectoryGridName, bool IterateOnlyLoadedSlices)
 
fiberbaseopQ_API RefPtr
< MemArray< 1, TriangleCell > > 
ConvexHull (const RefPtr< MemArray< 1, Eagle::PhysicalSpace::point >> &InputVertices, const double edge2D_max)
 interface to http://qhull.org/ version qhull-2015.2 More...
 
fiberbaseopQ_API TriangularSurface GenerateTriangularSurfaceFromPoints (Grid &OutputGrid, const RefPtr< MemArray< 1, Eagle::PhysicalSpace::point >> &InputVertices, const double edge2D_max)
 get connectivity as TriangularSurface
 
RefPtr< MemBasePartialDerivative (const RefPtr< MemBase > &SourceData)
 
bool isPartialDerivable (const RefPtr< CreativeArrayBase > &CAB)
 Check if the partial derivative can be computed from the given data. More...
 
RefPtr< CreativeArrayBasePartialDerivative (const RefPtr< CreativeArrayBase > &CAB, string &FailureDescription, const RefPtr< MemCore::Cache > &Cache)
 
RefPtr< FieldPartialDerivative (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. More...
 
template void GridEvaluator::findForSpecificDestinationPositions< DirectProductMemArray< Eagle::point3, LinearCoordinateAxisArray, 3 > > (const DirectProductMemArray< Eagle::point3, LinearCoordinateAxisArray, 3 > &, const Field &SourcePositions, GridEvaluator::Context &theEvaluationContext)
 
GridComputeIsosurface (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. More...
 
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 , int 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/. More...
 
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<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< GridrefineSurface (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< GridSplitMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid, const std::vector< bool > &modifyEdges)
 
RefPtr< GridRadialSplitMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid, const std::vector< bool > &modifyEdges, double radius, const point &center)
 
RefPtr< GridSplitMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid)
 Experimental refinement code.
 
bool DelaunayCriterion2D (const point &v1, const point &v2, const point &v3, const point &v4)
 
RefPtr< GridFlipMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid, const std::vector< bool > &flipableEdges)
 
RefPtr< GridFlipMeshEdges (Bundle &B, const RefPtr< Grid > &InputGrid, double threshold)
 
RefPtr< GridcreateUniformGrid3D (BundlePtr bp, double time, const string &grid_name, const Eagle::BoundingBox &bb, const MultiIndex< 3 > &dims)
 
RefPtr< GridcreateRegularlyFragmentedClusteredPointCloudGrid (BundlePtr bp, double time, const string &grid_name, const MultiIndex< 3 > &nr_fragments, const RefPtr< Eagle::BoundingBox > &bb)
 
RefPtr< GridcreateRegularlyFragmentedGridWithCartesianVertices3D (BundlePtr bp, double time, const string &grid_name, const MultiIndex< 3 > &nr_fragments)
 
RefPtr< FieldResampleRegularGrid3D (Grid &OutputGrid, const Grid &InputGrid, const string &Fieldname, const FixedArray< double, 3 > &IndexScale, const string &ChartName)
 
template<int 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())
 
gridop_API RefPtr< FieldResampleRegularGrid3D (Grid &OutputGrid, const Grid &InputGrid, const string &Fieldname, const FixedArray< double, 3 > &IndexScale, const std::string &ChartName=std::string())
 
RefPtr< MemBaserescale (double scale, const RefPtr< MemBase > &Data, const MemBase::Creator_t &Crec=NullPtr())
 
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. More...
 
template<int N, class T , class C >
MemCore::RefPtr< Eagle::KDTree
< N, T > > 
createTree (const C &coordinates, const unsigned size)
 create a KDTree More...
 
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< GridcreateUniformGrid (const string &InputGridname, const Info< Skeleton > &Level, const string &OutputGridname, const MultiIndex< 3 > &Resolution, const RefPtr< BoundingBox > &SubBox)
 
gridop_API RefPtr< GridprepareRegularlyFragmentedGrid (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. More...
 
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< GridDEPRECATED ("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. More...
 
gridop_API RefPtr< GridDEPRECATED ("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. More...
 
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. More...
 
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. More...
 
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. More...
 
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)
 
std::string InterpolateUniformDataOnGrid (Grid &Dest, Grid &UniformSource, const std::set< std::string > &myFields)
 
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. More...
 
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. More...
 
gridop_API std::string InterpolateUniformDataOnGrid (Grid &Dest, Grid &UniformSource, const std::set< std::__cxx11::string > &myFields)
 
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. More...
 
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< BoundingBoxgetVertexSelectionBounds (RefPtr< Grid > &grid, RefPtr< VertexSelection > &vs)
 
RefPtr< BoundingBoxgetVertexSelectionBounds (RefPtr< Grid > &grid, RefPtr< MemArray< 1, VertexSelection_t > > &vs)
 
RefPtr< VertexSelectiongetVertexSelection (RefPtr< Grid > &grid, const std::string &sel_name)
 
RefPtr< VertexSelectiongetMergedVertexSelection (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< FieldgetVertexSelectionPositions (RefPtr< Grid > &grid)
 
gridop_API RefPtr< RepresentationgetRefinedCartesianRepresentation (const RefPtr< Grid > &grid, double time, int ref)
 
gridop_API RefPtr< RepresentationgetRefinedCartesianRepresentation (GridSelector &gs, double time, int ref)
 
gridop_API RefPtr< RepresentationgetUnRefinedCartesianRepresentation (const RefPtr< Grid > &grid, double time)
 
gridop_API RefPtr< RepresentationgetUnRefinedCartesianRepresentation (GridSelector &gs, double time)
 
RefPtr< FieldgetRefinedCartesianVertexField (GridSelector &gs, double time, string field_name, int ref)
 
RefPtr< FieldgetUnRefinedCartesianVertexField (GridSelector &gs, double time, string field_name)
 
RefPtr< FieldgetCartesianVertexField (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. More...
 
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< FieldgetPrimaryOwner (const CreativeArrayBase &C)
 
RefPtr< RepresentationgetPrimaryOwner (const Field &F)
 
RefPtr< SkeletongetPrimaryOwner (const Representation &R)
 
RefPtr< GridgetPrimaryOwner (const Skeleton &K)
 
RefPtr< SlicegetPrimaryOwner (const Grid &G)
 
RefPtr< BundlegetPrimaryOwner (const Slice &S)
 
RefPtr< BundlegetPrimaryBundle (const Slice &S)
 
RefPtr< BundlegetPrimaryBundle (const Grid &G)
 
RefPtr< BundlegetPrimaryBundle (const Skeleton &K)
 
RefPtr< BundlegetPrimaryBundle (const Representation &R)
 
RefPtr< BundlegetPrimaryBundle (const Field &F)
 
RefPtr< BundlegetPrimaryBundle (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 ()
 
FiberAviation_API GridSelector getOpenSky (std::string &OpenSkyData, const RefPtr< Bundle > &B=nullptr, const std::string &Gridname="OpenSky", const std::function< double(time_t)> &TimeConvertr=nullptr, const string &Chartname="WGS-84")
 
FiberAviation_API GridSelector getOpenSky (const RefPtr< Bundle > &B=nullptr, const std::string &Gridname="OpenSky", const std::function< double(time_t)> &TimeConverter=nullptr, const string &Chartname="WGS-84")
 
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)
 
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 HDF5Load (RefPtr< Bundle > &Bndl, const string &url, const RefPtr< H5File > &theFile, const RefPtr< BundleLoaderProgress > &BLP, const RefPtr< StorageTransformations > &theStorageTransformations)
 
RefPtr< Loader< Bundle > > newHDF5Loader ()
 
void FiberIOHDF5_API HDF5Load (RefPtr< Bundle > &Bndl, const std::string &url, const RefPtr< H5File > &theFile, const RefPtr< BundleLoaderProgress > &BLP, const RefPtr< StorageTransformations > &theStorageTransformations)
 
bool FiberIOHDF5init ()
 Wrapper class for initialization. More...
 
template<int N>
bool FloatToDoublePrecision (const RefPtr< TypedChunkBase< FixedArray< double, N >>> &Dst, const RefPtr< TypedChunkBase< FixedArray< float, N >>> &Src)
 
template<int N>
bool ShiftedFloatToDoublePrecision (const RefPtr< TypedChunkBase< FixedArray< double, N >>> &Dst, const RefPtr< TypedChunkBase< FixedArray< float, N >>> &Src, const FixedArray< double, N > &Shift)
 
bool FloatToDoublePrecision (const RefPtr< ChunkBase > &Dst, const RefPtr< ChunkBase > &Src)
 
template<int N>
bool ShiftedFloatToDoublePrecision (const RefPtr< ChunkBase > &Dst, const RefPtr< ChunkBase > &Src, const FixedArray< double, N > &Shift)
 
RefPtr< MemBaseLoadArray (CreativeArrayBase &theCreator, const string &Description, const DynamicSize &DS, size_t MemSize, F5Fragment &theH5DatasetContext, const std::string &path_info, const RefPtr< StorageTransformations::IOPerformance > &IOP)
 
RefPtr< SizeInterfaceloadFieldSize (F5Path *field)
 Get a field's size without loading any data. More...
 
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< FieldContiguousField (F5Path *field, const RefPtr< FragmentIDCollection > &theFragmentIDCollection, const char *RepresentationName, const RefPtr< FiberIO::HDF5::FileNameInterface > &RepresentationFilePath, const string &fieldname, Grid &theGrid, const RefPtr< FiberTypeBase > &MyFiberType, const RefPtr< LoaderProgress > &TheLoaderProgressor)
 
RefPtr< FieldUniformField (F5Path *field, const RefPtr< FragmentIDCollection > &theFragmentIDCollection, const RefPtr< LoaderProgress > &TheLoaderProgressor)
 
template<class T >
void readRange (RefPtr< CreativeArrayBase > &cab, F5Path *f, hid_t F5type, const char *fragmentname="")
 
template<class T >
void readBoundingBox (RefPtr< CreativeArrayBase > &cab, F5Path *f, hid_t F5type, const char *fragmentname="")
 
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.
 
bool LoadImageSequence (RefPtr< Bundle > &Bndl, const RefPtr< LoaderParameters > &LP)
 
bool ImageSequenceAddLoader ()
 
void LoadImageSequence (const RefPtr< Bundle > &Bndl, const string &url)
 
bool endsWith (const char *s, const char *e)
 
int IOinit ()
 Initialize I/O layers for pre-defined template instantiations. More...
 
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)
 
void MKDIR (const string &path)
 
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 >
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< DataRangeBasegetRange (Field &F, const RefPtr< FragmentID > &f, bool AsynchRequest=false)
 Determine and eventually compute the numerical range of a field. More...
 
RefPtr< DataRangeBasegetRange (Field &F, string &ErrorMessage, bool AsynchRequest)
 
template<class Type >
std::array< double, 2 > getFloatDataRangeFromType (const Type &Minimum, const Type &Maximum)
 
template<class Type >
bool Contains (CreativeArrayBase &CAB, const Type &Value, bool ComputeEventually)
 
fiberop_API RefPtr< DataRangeBasegetRange (Field &F, std::string &ErrorMessage, bool AsynchRequest=false)
 
RefPtr< DataRangeBasegetRange (Field &F, bool AsynchRequest=false)
 
RefPtr< FieldBinaryDoubleAdditionComputationalField (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)
 
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)
 
RefPtr< MemBasepullData (const RefPtr< MemBase > &SourceData, const RefPtr< ChunkBase > &Indirection, const DynamicSize &DestSize)
 Create a MemBase from a given MemBase using indirect indexing of the given one, with the result placed into a multidimensional array. More...
 
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)
 
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)
 
RefPtr< MemBasepullData (const RefPtr< MemBase > &SourceData, const DynamicSize &DestSize, const RefPtr< ChunkBase > &Indirection)
 
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< MemBaseCreateSample (const RefPtr< MemBase > &Src, index_t DstElements, const SampleParameters &SP, const MemBase::Creator_t &C)
 
RefPtr< SizeInterfacegetSize (const CreativeArrayBase &CAB)
 
index_t NumberOfElements (const RefPtr< CreativeArrayBase > &CAB)
 
MemCore::memsize_t getMemoryUsage (const CreativeArrayBase &CAB)
 
RefPtr< MemBasegetMemBase (const MemCore::WeakPtr< CreativeArrayBase > &MemDataCreator)
 
RefPtr< MemCore::ChunkBasegetChunk (const MemCore::WeakPtr< CreativeArrayBase > &MemDataCreator)
 
RefPtr< MemBaseoperator- (const MemCore::WeakPtr< CreativeArrayBase > &MemDataCreator)
 
RefPtr< MemCore::ChunkBaseoperator+ (const MemCore::WeakPtr< CreativeArrayBase > &MemDataCreator)
 
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< SizeInterfaceoperator+ (const RefPtr< SizeInterface > &L, const RefPtr< SizeInterface > &R)
 
int getLinearIndex (const DynamicSize &theIndex, const DynamicSize &theSize)
 
bool operator< (const FiberTypeBase &l, const FiberTypeBase &r)
 
bool containsType (const TypeList_t &TL, const type_info &what)
 Investigate if a certain type is contained in a given type list.
 
std::tuple< RefPtr< Field >
, RefPtr< FragmentID > > 
operator<< (const RefPtr< Field > &F, const RefPtr< FragmentID > &Fid)
 
std::tuple< RefPtr< Field >
, RefPtr< FragmentID > > 
operator<< (const RefPtr< Field > &F, const string &FragmentName)
 
const RefPtr< CreativeArrayBase > & operator<< (const std::tuple< RefPtr< Field >, RefPtr< FragmentID >> &FF, const RefPtr< MemBase > &Mb)
 
const RefPtr< CreativeArrayBase > & operator>> (const std::tuple< RefPtr< Field >, RefPtr< FragmentID >> &FF, Field::CAB_t &Result)
 
const RefPtr< CreativeArrayBase > & operator<< (const std::tuple< RefPtr< Field >, RefPtr< FragmentID >> &FF, const Field::CAB_t &theCreator)
 
template<class Functor >
FunctionalCreatoroperator+= (const std::tuple< Field *, RefPtr< FragmentID >> &FieldFragment, const Functor &Lambda)
 
template<class Functor >
FunctionalCreatoroperator+= (const Field &F, const Functor &Lambda)
 
const RefPtr< CreativeArrayBase > & operator<< (const std::tuple< RefPtr< Field >, RefPtr< FragmentID >> &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)
 
 FragmentIDContainer ()
 
 FragmentIDContainer (const FragmentIDContainer &)
 
FragmentIDContainer & operator= (const FragmentIDContainer &)
 
size_t nFragments () const
 Return the number of fragments stored here.
 
RefPtr< FragmentIDgetFirst () const
 Get the first fragment from the set. More...
 
void insert (const RefPtr< FragmentID > &Fid)
 
RefPtr< FragmentIDcreateFragmentID (const string &name)
 
int iterate (Iterator &) const
 
template<class Functor >
RefPtr< FunctionalCreatornewFunctionalCreator (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<int 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!). More...
 
template<int 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. More...
 
RefPtr< MemCore::ChunkBasegetChunk (const MemCore::WeakPtr< MemBase > &MemData)
 
RefPtr< MemCore::ChunkBaseoperator- (const RefPtr< MemBase > &Mem)
 
RefPtr< FieldnewRegularlyFragmentedField (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< MemBaseShift (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. More...
 
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_tChartCreatorRegistry ()
 
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.
 
std::string to_string (const Skeleton &S)
 
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<int 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. More...
 
int log2 (index_t arg)
 Compute the logarithm to the basis of two from the given index. More...
 
index_t RoundUpToNextHighestPowerOf2 (index_t v)
 Align a value to the next fitting power of 2. More...
 
index_t clamp (index_t value, index_t range)
 
index_t clamp_m1 (index_t value, index_t 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. More...
 
template<class Type >
Iterator< Typearray_iterator (const Iterator< Type > &It)
 Specialization of the array_iterator() function for Iterators on what is already a FixedArray. More...
 
template<class Type >
Iterator< Typearray_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)
 
void checkMultiCopy (MultiArray< 3, unsigned char > &Dest, const MultiArray< 3, double > &Src)
 
template<class Dest , class Source , int 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 , int 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 , int 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 , int 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 , int 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.
 
MultiIndex< 1 > MIndex (index_t i0)
 
MultiIndex< 2 > MIndex (index_t i0, index_t i1)
 
MultiIndex< 3 > MIndex (index_t i0, index_t i1, index_t i2)
 
MultiIndex< 4 > MIndex (index_t i0, index_t i1, index_t i2, index_t i3)
 
template<int 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))
 
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. More...
 
template<int internalformat, typename TextureProbeType >
RefPtr< Wizt::GLTexture3DcreateScaledTexture3D (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::GLTexture3DcreateTexture3Di (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::GLTexture3DcreateTexture3D (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. More...
 
RefPtr< Wizt::GLTexture2DcreateTexture2D (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. More...
 
void renderQuad (const RefPtr< Wizt::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::GLTexture2DcreateTexture2D (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::GLTexture2DcreateTexture2D (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::GLTexture3DcreateTexture3D (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.
 

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. More...
 
const char CurveParameterFieldName [] = "length"
 A default name for the field that holds the respective values of a curve parameter. More...
 
class BUNDLE_API Bundle
 
class BUNDLE_API StorageTransformations
 
class BUNDLE_API GridList
 
class BUNDLE_API SliceMap
 
class BUNDLE_API Slice
 
class BUNDLE_API GridSelector
 
FiberType< double > FT (true)
 
class FIELD_API FragmentIDCollection
 
class FIELD_API[[deprecated("Use
FragmentIDCollection instead")]] 
FragmentIDContainer
 
FragmentIDset_t FragmentIDset
 
class FIELD_API MemBase
 
class FIELD_API CreativeArrayBase
 
FIELD_API template class 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

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.

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

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

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().

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< ContainerClass >::getArrayIterator().

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 computeIndicesSelectionByShape().

Referenced by computeIndicesSelectionByShape().

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
TimeStepThe 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.
isosurfacenameThe name of the new isosurface grid, as to be created in the provided time slice

References Fiber::Grid::CartesianPositions(), Fiber::Grid::makeChart(), Fiber::SkeletonMap::makeVertices(), Fiber::Slice::newGrid(), Fiber::Representation::Positions(), and Fiber::FragmentIsoSurfacer::setFields().

Referenced by renderVolume().

fiberbaseopQ_API RefPtr<MemArray<1,TriangleCell> > Fiber::ConvexHull ( const RefPtr< MemArray< 1, Eagle::PhysicalSpace::point >> &  InputVertices,
const double  edge2D_max 
)

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

get connectivity as MemArray

gridop_API 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>
fishGL_API 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
BitsPerTexelThe 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().

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 Eagle::KDTree< N, T >::insert().

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())   
)

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.
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)   
)

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.
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
DestGridSliceSlice 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.
DestGridNameName of the destination grid in the destination slice, used to build an internal helper grid on the same slice.
StoreResultFlag 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(), EvalGrid(), Fiber::SkeletonMap::findVertices(), and Fiber::Grid::makeChart().

Referenced by EvalGrid().

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 ExecuteExpression(), Fiber::FiberMap< ID >::findMostFragmentedField(), Fiber::Field::getElementType(), Fiber::Representation::iterate(), Fiber::FieldID::Name(), and Typename().

Referenced by ExecuteExpression().

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

Expand a given bounding box by the given data array.

Parameters
BBoxIf the bounding box is null pointer, it will be assigned with the properties of the coordinate array, otherwise it will be expanded.
CABA creator for the data array, might be procedural or explicitely stored.
DataCreationModeUnder which conditions to create data:
  1. 0 - always create data and scan when if needed
  2. 1 - compute bounding box only when data exists in memory, otherwise request them for a subsequent call and return false for now
  3. 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 ComputeOnlyIfAvailable, ComputeOrRequest, MemCore::CreatorBase< Domain >::create(), Eagle::BoundingBox::embrace(), ExpandBBox(), MemCore::CreatorBase< Domain >::get(), MemCore::Attributes::getAttribute(), MemCore::CreatorBase< Domain >::request(), and MemCore::Attributes::touchAttributes().

Referenced by Fiber::BBoxExpander::apply(), ExpandBBox(), and Wizt::GridAnemone::getModifiedBBox().

gridop_API bool Fiber::expandBoundingBox ( const RefPtr< Field > &  Coords,
RefPtr< BoundingBox > &  theBox 
)

Note that the bounding box on the Field itself will be cached there.

References Fiber::BBoxExpander::expand().

gridop_API bool Fiber::expandBoundingBox ( RefPtr< BoundingBox > &  theBox,
const RefPtr< Field > &  Coords 
)

Note that the bounding box on the Field itself will be cached there.

This version is just another order of parameters, but does the same as the above function of the same name. It is just provider here for convenience.

References Fiber::BBoxExpander::expand().

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.
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:
RefPtr< FragmentID > Fiber::FragmentIDContainer::getFirst ( ) const

Get the first fragment from the set.

Note that it might be Null, as being Null is a valid FragmentID. It will also return a NullPtr() if no fragments are stored here at all.

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).

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.

fiberop_API RefPtr< DataRangeBase > Fiber::getRange ( Field &  F,
const RefPtr< FragmentID > &  f,
bool  AsynchRequest = false 
)

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 Fiber::Field::getElementType(), and Typename().

gridop_API getSkeletonFieldsResults_t Fiber::getSkeletonFields ( const RefPtr< Fiber::Skeleton > &  DestVertexSkeleton,
const RefPtr< Fiber::Chart > &  chart,
const FieldSelector FS,
const Fiber::Info< Fiber::Grid > &  DestinationGrid,
const string &  ImplicitFieldName = string() 
)
Parameters
DestVertexSkeletonWe want a field on this Skeleton.
FSThe field selector describing the field that we look for.
chartWe want the field in this chart.
DestinationGridThe context information of the Skeleton where we want the Field. The DestVertexSkeleton will be contained in this Grid and Grid context.
ImplicitFieldNameThe name of a field that may be given on the grid and is used instead of a valid FieldSelector if a grid is defined.

References getSkeletonFields().

Referenced by Wizt::ShaderFields::getSkeletonField(), and getSkeletonFields().

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.

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)

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

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
template<typename T >
T Fiber::iniTIFF ( TIFF *  OutTIFF,
const MultiIndex< 3 > &  FragDims,
const tvector &  CellSize 
)

TILES INFO

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
UMapThe uniform cartesian array
HeighfieldSome scalar field given on the same index space as UMap
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 
)

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
UMapThe uniform cartesian array
HeighfieldSome scalar field given on the same index space as UMap
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().

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 isPartialDerivable().

Referenced by isPartialDerivable(), and PartialDerivative().

RefPtr< SizeInterface > Fiber::loadFieldSize ( F5Path *  field)

Get a field's size without loading any data.

Calls F5Tget_space();

Referenced by UniformField().

bool Fiber::LoadImageSequence ( RefPtr< Bundle > &  Bndl,
const RefPtr< LoaderParameters > &  LP 
)

Protect against non-evolving filename sequencea

References Fiber::Grid::makeCartesianRepresentation(), and Fiber::Representation::setPositions().

int Fiber::log2 ( index_t  arg)
inline

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

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.

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

References Fiber::LinearDirectProductMemArray< T, DeltaT, MDIMS >::getNearestMultiIndex(), Fiber::MultiArrayBase< N, T >::Size(), and Fiber::DirectProductMemArrayBase< T, Category, MDIMS >::Size().

Referenced by MapToUniformIndex().

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.} 
)

Create a height field.

Parameters
InvalidDataNumerical value to fill points that are not in the input data array.
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
InvalidDataNumerical value to fill points that are not in the input data array.

References MapToUniform(), and Fiber::DirectProductMemArrayBase< T, Category, MDIMS >::Size().

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().

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
FThe field that should be partially derived.
NewFieldnameThe name of the newly created field as it will be inserted into the CurrentRepresentation
CurrentRepresentationThe current representation.
FieldIDSourceThe 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 Fiber::FragmentIterator::apply(), Fiber::Representation::createSharedFieldID(), Fiber::Field::getCreator(), and Fiber::Field::setCreator().

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
FEThe field to be explored

References Fiber::MultiIndex< Dims >::BitIndex(), and ComputeInterpolationEdgeAndWeight().

fishGL_API 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
TSTexturescale - allows to multiply texture coordinates by this factor
TOffsetTexture 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().

gridop_API RefPtr< MemBase > Fiber::rescale ( double  scale,
const RefPtr< MemBase > &  Data,
const MemBase::Creator_t &  Crec = NullPtr() 
)
Parameters
FieldIDSourceAn optional Representantation that already carries some field identifier that is to be shared for the newly generated field.

References rescale().

Referenced by rescale().

index_t Fiber::RoundUpToNextHighestPowerOf2 ( index_t  v)
inline

Align a value to the next fitting power of 2.

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

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
LineIntegratorAnalyticContainerA container type for analytical line integrators, for instance std::vector<LineIntegratorAnalytic>
AnalyticLineIntegratorsThe 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.
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

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";

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"
)
Fiber::FragmentIDContainer::FragmentIDContainer
Initial value:
{
typedef std::set<RefPtr<FragmentID>, CompareFragmentIDs> FragmentIDset_t
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(), and Fiber::LineSet::LineSet().