Workspace 6.21.5
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
CSIRO::Mesh Namespace Reference

Mesh model data structures. More...

Namespaces

namespace  ElementType
 
namespace  MapStates
 
namespace  MultiElementTypeHelper
 Helper functions for dealing with multiple element types.
 
namespace  PrimevalMeshModelInterfaceTemplates
 
namespace  Ui
 

Classes

class  AccumulateNodeValues
 
class  AddMeshModelState
 Adds a state to the mesh model of a specified type. More...
 
class  AddNodesToMesh
 Adds nodes to a MeshModel. More...
 
class  AddScalarStateToMesh
 Adds Vector3d state values to a MeshModel. More...
 
class  AddVectorStateToMesh
 Adds Vector3d state values to a MeshModel. More...
 
class  AppendToModelTimeline
 
struct  ApplyFunctor
 
struct  ApplyFunctor< F, ShellElement >
 
class  AscReader
 Read a PLY file. More...
 
class  Attached
 Defines a class for handling attached objects (nodes, elements, etc.). More...
 
class  Attachments
 Defines a class for handling attached objects (nodes, elements, etc.). More...
 
class  BaseModel
 Basic model interface class from which all model types should eventually derive. More...
 
class  BaseReader
 Base class from which all file readers must inherit. More...
 
class  BaseWriter
 Base class from which all file writers must inherit. More...
 
class  BinaryMeshModelReader
 
class  BinaryMeshModelWriter
 
class  BitSet16
 
class  BoundingBox
 Describes a bounding box region in 3D space. More...
 
class  BoundingBoxBuilder
 Provides a builder operation for BoundingBox objects. More...
 
class  BoundingBoxMinimal
 
class  BoundingBoxOfModels
 Provides an operation for creating a BoundingBox around an array of MeshModels. More...
 
class  BoundingCylinder
 Describes a bounding cylinder region in 3D space. More...
 
class  BoundingCylinderBuilder
 Provides a builder operation for BoundingCylinder objects. More...
 
class  BoundingPlane
 Describes a bounding plane region in 3D space. More...
 
class  BoundingPlaneBuilder
 Provides a builder operation for BoundingPlane objects. More...
 
class  BoundingSphere
 Describes a bounding sphere region in 3D space. More...
 
class  BoundingSphereBuilder
 Provides a builder operation for BoundingSphere objects. More...
 
class  CalculateMultiNodeNormals
 Adds a node normal state to the mesh using Mesh::MultiNodeNormals. More...
 
class  CalculateSurfaceArea
 Operation to calculate the surface area of a mesh. More...
 
class  CenterMeshModel
 Centers a mesh model around world 0,0,0. More...
 
class  Collisions
 Define a class for collision and penetration testing. More...
 
class  CopyElementState
 Copies data from one element state to another within the same model. More...
 
class  CopyNodeState
 Copies data from one node state to another within the same model. More...
 
class  CreateHeightMeshFromArrayNd
 
class  CreateMeshModelFromCylinder
 Creates a MeshModel from a BoundingCylinder. More...
 
class  CreateMeshModelFromDataSeries
 Create a MeshModel from 3 DataSeries - one for each axis. More...
 
class  CreateMeshModelInterface
 Operation to create a particular type of MeshModelInterface. More...
 
class  CreateRgbaState
 Create a packed RGBA state from exising states for use with the ColorStateShader. More...
 
class  CreateTruncatedConeMeshModel
 Creates a MeshModelInterface from a TruncatedCylinder. More...
 
struct  DuplicateElementError
 Duplicate shell element exception class. More...
 
class  Element
 Defines a generic element class. More...
 
class  ElementCriterion
 Abstract base class defining an interface for pass/fail criterion for an Element. More...
 
class  ElementCriterionAllPass
 Element criterion that will pass for all elements. More...
 
class  ElementCriterionInRegion
 Element criterion that will pass for all elements in a provided Region. More...
 
struct  ElementEdge
 Defines an edge as a pair of nodes. More...
 
struct  ElementEdgeComp
 Binary comparison functor for ElementEdge objects. More...
 
class  ElementHandle
 A handle to an element in a MeshModelInterface. More...
 
class  ElementList
 Class for storing a list of T objects. More...
 
class  ElementMapper
 Base class defining an interface for mapping a model's elements to values. More...
 
class  ElementScriptMapper
 Element mapper using QtScript to return a value for an element. More...
 
class  ElementScriptMapperBuilder
 Generates a ElementScriptMapper object. More...
 
class  ElementStateHandle
 A handle to an element state. More...
 
class  ElementStateMapper
 Element mapper returning a particular element state as its value 2015-07-10:DGT: Class is extended to be able to return a data object. This was driven by the existence of vector states on volume (hexahedral) elements. More...
 
class  ElementStateMapperBuilder
 Generates a ElementStateMapper object. More...
 
class  EnsightWriter
 Provides an operation for writing Ensight files. More...
 
class  EnsureElementStateExists
 Tests that an element state in a meshmodel exists, and if it doesn't, creates one. More...
 
class  EnsureMeshUnorganised
 Convert an organised mesh to an unorganised one (usually for rendering in Workspace). More...
 
class  EnsureNodeStateExists
 Tests that a user-specified node-state in a meshmodel exists, and if it doesn't, creates it. More...
 
class  Entity
 Defines an entity with a component ID. More...
 
class  ExtractRgbaState
 Extract RGBA states from exising packed RGBA states. More...
 
class  Extrude2dMesh
 Creates a 3D meshmodel from a 2D meshmodel by extruding it in the third dimension. More...
 
class  FaceIterator
 This class provides an iterator that iterates through all the faces in a container of VolumeElement's. More...
 
class  FilteredMeshElementsInterface
 Provides node and element filtering to a MeshModelInterface. More...
 
class  FilteredMeshModelInterface
 Provides node and element filtering to a MeshModelInterface. More...
 
class  FilteredMeshNodesInterface
 
class  FilterMeshModel
 Operation to filter the nodes or elements contained within a MeshModelInterface. More...
 
class  FindStateAverage
 Find the average value for a specified state. More...
 
class  FindStateRange
 Find the minimum and maximum values for a specified state. More...
 
class  FlagCopy
 
class  FlagSetter
 
class  GeometricPlaneFilter
 A MeshModelInterface filter for filtering nodes based on their position relative to a plane. More...
 
struct  GetListClass
 
struct  GetListClass< Node >
 
struct  GetListClass< Segment >
 
struct  GetListClass< ShellElement >
 
struct  GetListClass< VolumeElement >
 
class  GetMeshNodeStateAsDataSeries
 
class  GetMeshNodeStateAsObjectArray
 Extracts the state data from a mesh nodes. More...
 
class  GetMeshNodeStates
 
class  GetModelFromSource
 Retrieves the MeshModel from the specified MeshModelSource, causing the MeshModelSource to bring itself up-to-date. More...
 
class  GetModelIdFromSource
 Retrieves the ModelId string from a MeshModelSource operation. More...
 
class  GetSourceFromMeshModelLibrary
 Retrieves a specific source from a mesh model library. More...
 
class  HierarchicalReferenceMeshModelInterface
 MeshModelInterface implementation that has no node data of its own, rather it references data in an existing mesh, and "inherits" a set of nodes in a parent mesh. It is ideal for reusing point cloud data that is hierarchically represented. More...
 
class  HierarchicalReferenceMeshNodesInterface
 A set of nodes that are really just references to other nodes elsewhere. More...
 
class  iautogzstream
 File stream input with gzip functionality. More...
 
class  IGESArc
 
class  IGESBaseEntity
 
class  IGESDirectoryEntry
 
class  IGESLine
 
class  IGESReader
 Reads IGES models. More...
 
class  IgesReaderOperation
 Provides an operation for reading ASCII IGES files. More...
 
class  IGESTransformMatrix
 
struct  InconsistentSurfaceNormalsError
 Inconsistent shell element normals exception class. More...
 
class  IndexToNumberedObjectMap
 Maps the index of a NumberedObject in a NumberedObjectList<T> to the object. More...
 
class  InvertNormals
 Inverts the normals of a mesh: nodes and elements. More...
 
class  InvertTransformMatrix
 Inverts a transform matrix, reversing the transformation. Will fail if (somehow) the transform matrix is not invertible. More...
 
class  IsFlagSet
 Functor for testing if a specified flag is set for numbered objects. More...
 
class  ItemHandle
 A base class for handles to some item in a MeshModelInterface such as a node, element or state. More...
 
class  KillInvalid
 Functor to call KillObject if the object is marked as invalid (i.e. awaiting deletion). More...
 
class  KillInvalid< Node >
 
class  KillObject
 Functor for deleting an object and NULL-ifying the list pointer to it./. More...
 
class  LargeStreamlinedMeshModelInterface
 
class  Line
 A geometric line; a point and a direction. More...
 
struct  ListTraits
 Traits class to provide a typedef for the list type for an object. More...
 
struct  ListTraits< Node >
 
struct  ListTraits< Segment >
 
struct  ListTraits< ShellElement >
 
struct  ListTraits< VolumeElement >
 
class  LodMeshModel
 Produces a reduce level of detail (LOD) mesh. More...
 
class  LodMeshModelInterface
 
class  LodMeshNodesInterface
 
class  LodMeshTrianglesInterface
 
class  MapElementStatesToNodes
 Map element states onto that element's nodes. More...
 
class  MapNodeStatesToElements
 Creates an element-state by averaging the specified node-state onto the attached elements. More...
 
class  MapScalarNodeStateToRgbaState
 Tests that a user-specified node-state in a meshmodel exists, and if it doesn't, creates it. More...
 
struct  MapStorage
 Storage policy for using a map. More...
 
class  Matrix3x3
 3x3 matrix class meant for compute-intensive use More...
 
class  Matrix3x3Group
 Object group containing a 3x3 matrix of floating point numbers. More...
 
class  Matrix3x3Widget
 Widget for displaying / editing the contents of a Matrix3x3Group. More...
 
class  Matrix3x3WidgetConnector
 Connects a Matrix3x3Widget to a Matrix3x3Group data object. More...
 
class  Matrix3x3WidgetFactory
 Widget factory for a Matrix3x3Widget. More...
 
class  MergeModels
 Merges a set of MeshModel objects into a single model. More...
 
class  MeshElementsInterface
 An interface to the elements stored behind a MeshModelInterface. More...
 
class  MeshFeatureIdentifier
 Class for identifying surface features of a mesh. More...
 
class  MeshFromBoundingBox
 Operation to create a mesh model from a bounding box. More...
 
class  MeshFromBoundingPlane
 Operation to create a mesh model from a bounding plane. More...
 
class  MeshFromBoundingSphere
 Operation to create a mesh model from a bounding sphere. More...
 
class  MeshModel
 Mesh model class to provide node and element lists. More...
 
class  MeshModelBeingDestroyedEvent
 
class  MeshModelDiskCache
 Allows MeshModel data to be cached to disk when the cache size is exceeded. More...
 
class  MeshModelFilter
 Base class for MeshModelInterface filters. More...
 
class  MeshModelFilterWidget
 Widget for displaying and modifying MeshModelFilters. More...
 
class  MeshModelFilterWidgetDesigner
 Qt Designer support for MeshModelFilterWidget. More...
 
class  MeshModelInfo
 Prints details about the MeshModel to the log. More...
 
class  MeshModelInterface
 A base class for an interface to a mesh model. More...
 
class  MeshModelInterfaceComboBox
 Specialization of QComboBox for supported different MeshModelInterface implementations. More...
 
class  MeshModelInterfaceComboBoxConnector
 Connects a TransformByComponents widget to a TransformMatrix data object. More...
 
class  MeshModelInterfaceComboBoxDesigner
 Qt Designer support for MeshModelInterfaceComboBoxWidget. More...
 
class  MeshModelInterfaceComboBoxFactory
 Widget factory for a QComboBox whose items reflect the supported mesh reader formats. More...
 
class  MeshModelInterfaceInfo
 Outputs details of a MeshModelInterface. More...
 
class  MeshModelInterfaceInspectorWidget
 Widget for inspecting nodes and elements of a MeshModelInterface. More...
 
class  MeshModelInterfaceInspectorWidgetConnector
 Connects a MeshModelInterfaceInspectorWidget to a MeshModelInterface data object. More...
 
class  MeshModelInterfaceInspectorWidgetDesigner
 Qt Designer support for MeshModelInterfaceInspectorWidget. More...
 
class  MeshModelInterfaceInspectorWidgetFactory
 Widget factory for a MeshModelInterfaceInspectorWidget. More...
 
class  MeshModelInterfaceRegistry
 A registry of MeshModelInterface implementations which can be used to create new instances. More...
 
class  MeshModelInterfaceSummaryWidget
 
class  MeshModelInterfaceSummaryWidgetConnector
 Connects a MeshModelInterfaceSummaryWidget to a MeshModelInterface data object. More...
 
class  MeshModelInterfaceSummaryWidgetDesigner
 Qt Designer support for MeshModelInterfaceSummaryWidgetWidget. More...
 
class  MeshModelInterfaceSummaryWidgetFactory
 Widget factory for a MeshModelInterfaceSummaryWidget. More...
 
class  MeshModelInterfaceToMeshModelAdaptor
 Adapts a MeshModelInterface to a MeshModel. More...
 
class  MeshModelInterfaceWidget
 Widget for displaying properties of a MeshModelInterface. More...
 
class  MeshModelInterfaceWidgetConnector
 Connects a MeshModelInterfaceWidget to a MeshModelInterface data object. More...
 
class  MeshModelInterfaceWidgetDesigner
 Qt Designer support for MeshModelInterfaceWidgetWidget. More...
 
class  MeshModelInterfaceWidgetFactory
 Widget factory for a MeshModelInterfaceWidget. More...
 
class  MeshModelLibrary
 Effectively acts like a container for MeshModelSource objects. More...
 
class  MeshModelLibraryBuilder
 Generates a MeshModelLibrary from a list of MeshModelSource and MeshModelLibrary inputs. More...
 
class  MeshModelLibraryInfo
 Retrieves information about a mesh model library. More...
 
class  MeshModelSource
 Makes a MeshModel source available without having to first read in the MeshModel data. More...
 
class  MeshModelStateInfo
 Provide lists of node and element states for a model. More...
 
class  MeshModelToMeshModelInterfaceAdaptor
 Adapts a MeshModel to a MeshModelInterface. More...
 
class  MeshModelWidget
 
class  MeshModelWidgetConnector
 Connects a MeshModelWidget to a Matrix3x3Group data object. More...
 
class  MeshModelWidgetDesigner
 Qt Designer support for TransformByComponentsWidget. More...
 
class  MeshModelWidgetFactory
 Widget factory for a MeshModelWidget. More...
 
class  MeshNodesInterface
 An interface to the nodes stored behind a MeshModelInterface. More...
 
class  MeshPlugin
 WorkspacePlugin singleton class for this module. More...
 
class  MeshPluginDesigner
 WorkspacePlugin singleton class for this module. More...
 
class  MeshReader
 Base class from which all file readers that import meshes must inherit. More...
 
class  MeshReadersComboBox
 Specialization of QComboBox for supported mesh reader formats. More...
 
class  MeshReadersComboBoxConnector
 Connects a TransformByComponents widget to a TransformMatrix data object. More...
 
class  MeshReadersComboBoxDesigner
 Qt Designer support for MeshReadersComboBoxWidget. More...
 
class  MeshReadersComboBoxFactory
 Widget factory for a QComboBox whose items reflect the supported mesh reader formats. More...
 
class  MeshSerializer
 Helper class for writing MeshModelInterface data to Workspace Binary Mesh (.wbm) format. More...
 
class  MeshWriter
 Base class from which all mesh model writers must inherit. More...
 
class  MultiNodeNormals
 Provides a set of normals associated with a node based on attached elements. More...
 
struct  MultipleFreeEdgesError
 Multiple free edges exception class. More...
 
class  NasReader
 Reader for Nastran mesh files. More...
 
class  NastranReader
 Reads Nastran models. More...
 
class  NastranReaderOperation
 Provides an operation for reading nastran files. More...
 
class  NastranWriter
 Writes models in Nastran format. More...
 
class  NastranWriterOperation
 Provides an operation for writing nastran files. More...
 
class  Node
 Defines a node in (x,y,z) space with an ID. The node also has state info. More...
 
class  NodeCriterion
 Abstract base class defining an interface for pass/fail criterion for a Node. More...
 
class  NodeCriterionAllPass
 Node criterion that will pass for all nodes. More...
 
class  NodeCriterionInRegion
 Node criterion that will pass for all nodes in a provided Region. More...
 
class  NodeHandle
 A handle to a node in a MeshModelInterface. More...
 
struct  NodeHandleIndexLookup
 
class  NodeIdCriterion
 Node criterion that will pass for all nodes having a given id. More...
 
class  NodeIdCriterionBuilder
 This operation converts a long into a NodeIdCriterion. More...
 
class  NodeIdCriterionFromModel
 This operation takes a MeshModel and creates a NodeIdCriterion for that model's node ID's. More...
 
class  NodeList
 Class for storing a list of nodes. More...
 
class  NodeMapper
 Base class defining an interface for mapping a model's nodes to values. More...
 
class  NodeScriptMapper
 Node mapper using QtScript to return a value for a node. More...
 
class  NodeScriptMapperBuilder
 Generates a NodeScriptMapper object. More...
 
class  NodeStateHandle
 A handle to a node state. More...
 
class  NodeStateHistogram
 
class  NodeStateMapper
 Node mapper returning a particular node state as its value. More...
 
class  NodeStateMapperBuilder
 Generates a NodeStateMapper object. More...
 
class  NodeTextureMapper
 A NodeTextureMapper uses the texture coordinates stored in the state data associated with a node to lookup and return a value stored in a matrix of scalar data (texture). More...
 
class  NodeTextureMapperBuilder
 Generates a NodeStateMapper object. More...
 
class  NullNodeMapper
 Default class for a node mapper where one is not provided. Simply returns a value of 0.0 for all node states. More...
 
class  NullOperationMeshModelFilter
 A MeshModelInterface filter that does nothing. It is the default type when a filter is added to the input array of FilterMeshModel. More...
 
class  NumberedObject
 Defines an object with an ID and index (generally used as a base class). More...
 
class  NumberedObjectList
 Defines a list of numbered objects and is generally used as a base class. More...
 
class  oautogzstream
 File stream output with gzip functionality. More...
 
class  ObjectTransforms
 
class  ObjReaderOperation
 Provides an operation for reading OBJ files. More...
 
class  Octree
 
class  OctreeItem
 
class  OctreeNode
 A node in the octree. More...
 
class  OctreeVector3
 Templated Vector3 class for use by the Octree. More...
 
class  PartitionConstantBase
 
class  PartitionConstantData
 Data structure for partitioning with a constant interval grid. More...
 
class  PartitionConstantGrid
 
class  PartitionConstantTraits
 Traits for the storage policy (also defines the data data member). More...
 
class  PlyReader
 Read a PLY file. More...
 
class  PlyWriter
 Writes models in VTK ASCII or Binary format. More...
 
class  PlyWriterOperation
 Provides an operation for writing Vtk files. More...
 
class  PointMass
 Define the point mass class. More...
 
class  PointModel
 Provides a model containing a single point. More...
 
class  PrimevalMeshElementsInterfaceBase
 
class  PrimevalMeshModelInterface
 
class  PrimevalMeshNodesInterface
 
class  PrimevalQuads
 
class  PrimevalSegments
 
class  PrimevalTris
 
class  PrimevalVolumes
 
class  Properties
 Defines a class holding a named set of generic properties as strings. More...
 
class  PropertySet
 Extends the generic Properties class to associate with it a templated ID. More...
 
class  ProximityNodes
 Class for storing and manipulating a list of ShellElement objects. More...
 
class  QuadSplitter
 Helper class for splitting quad shell elements. More...
 
class  QVectorVector3dWidget
 
class  QVectorVector3dWidgetConnector
 
class  QVectorVector3dWidgetFactory
 
class  Region
 Abstract base class defining an arbitrary region in 3D space. More...
 
class  RegionAsElementCriterion
 This operation converts a Region into an ElementCriterion. More...
 
class  RegionAsNodeCriterion
 This operation converts a Region into a NodeCriterion. More...
 
class  RegionIntersection
 Defines an intersection of an arbitrary number of regions. More...
 
class  RegionIntersectionOperation
 This operation provides a region that is the intersection of its input regions. More...
 
class  RegionNegate
 Defines the logical negation of a region. More...
 
class  RegionNegateOperation
 This operation provides a region that is the negation of its input. More...
 
class  RegionProcessor
 
class  RegionTransform
 Applies an arbitrary affine transformation to a region. More...
 
class  RegionTransformOperation
 This operation provides a region that transforms another region. More...
 
class  RegionUnion
 Defines a union of an arbitrary number of regions. More...
 
class  RegionUnionOperation
 This operation provides a region that is the union of its input regions. More...
 
class  RemoveStatesFromMesh
 Removes states from a mesh based on a comma separated list. More...
 
class  RenameNodeStates
 An operation to rename node states. More...
 
class  ScalarNodeStateFilter
 A MeshModelInterface filter for scalar node states. More...
 
struct  ScaledZeroVectorError
 Exception class for when an attempt is made to scale a zero vector. More...
 
struct  SearchRegion
 
class  Segment
 Defines a segment element class. More...
 
class  SegmentList
 Class for storing and manipulating a list of Segment objects. More...
 
class  SelectableMeshReader
 Read a mesh model using a selectable reader type. More...
 
class  SelectableMeshReaders
 Singleton class that provides an extensible list of mesh readers. More...
 
class  SetMeshModelInterfaceMetaData
 Set the meta data (ObjectDictionary) on a MeshModelInterface. More...
 
class  ShellElement
 The shell element class defines triangular and quadrilateral polygonal elements. More...
 
class  ShellElementList
 Class for storing and manipulating a list of ShellElement objects. More...
 
struct  ShellSurfaceError
 Base class for all exceptions related to processing shell surfaces. More...
 
class  SmoothMeshModel
 Produces a smoothed model. More...
 
class  SphericalToCartesian
 Operation to convert spherical coordinates to cartesian. More...
 
class  SplitTriangleFaces
 Split triangle faces on a mesh. More...
 
class  State
 Defines state info for an object. More...
 
class  StateControl
 Defines a class to manipulate State objects. More...
 
class  StateHandle
 Base class for state handles. More...
 
class  StateInfo
 Defines a class to hold info for one particular state. More...
 
class  StateMap
 
class  StateSelector
 Helper class for getting a state whose type depends on a template parameter. More...
 
class  STLAsciiReader
 
class  STLBinaryReader
 
class  STLReader
 Reads models in STL format (ASCII only). More...
 
class  StlReaderOperation
 Provides an operation for reading ASCII STL files. More...
 
class  StlWriter
 
class  StreamlinedMeshElementsInterface
 
class  StreamlinedMeshModelInterface
 
class  StreamlinedMeshModelInterfaceImpl
 
class  StreamlinedMeshNodesInterface
 
class  StreamlinedStateStorage
 
struct  SurfaceIntersectError
 Multiple surface intersect exception class. More...
 
class  TecPlotReader
 Reads models in TecPlot format (triangular shells only) More...
 
struct  ThinWedgeError
 Overlaid shell elements exception class. More...
 
class  TransformByComponents
 Specify a transform matrix by its components. More...
 
class  TransformByComponentsConnector
 Connects a TransformByComponents widget to a TransformByComponents data object. More...
 
class  TransformByComponentsFactory
 Widget factory for TransformByComponents widget attached to a TransformByComponents data object. More...
 
class  TransformGroup
 Object group defining an arbitrary 3D transformation. More...
 
class  TransformGroupAdaptor
 Adapts a TransformGroup object to a TransformMatrix. More...
 
class  TransformMatrix
 
class  TransformMatrixBuilder
 Operation to build a TransformMatrix object from a TransformGroup. More...
 
class  TransformMatrixConnector
 Connects a TransformByComponents widget to a TransformMatrix data object. More...
 
class  TransformMatrixFactory
 Widget factory for TransformByComponents widget attached to a TransformMatrix data object. More...
 
class  TransformMatrixMultiply
 Operation to apply a sequence of transforms in turn (equivalent to matrix multiplication) More...
 
class  TransformMatrixWidget
 
class  TransformMatrixWidgetDesigner
 Qt Designer support for TransformMatrixWidgetWidget. More...
 
class  TransformModel
 Provides an operation for transforming a model's nodes. More...
 
class  TransformVector
 Operation to apply a sequence of transforms in turn (equivalent to matrix multiplication) More...
 
class  TriangulateMesh
 Convert quad elements to triangles. More...
 
class  TriSplitter
 Helper class for splitting tri shell elements. More...
 
class  TruncatedCone
 Describes a truncated cone in 3D space. More...
 
class  TypedMeshModelFilter
 Allows polymorphic serialization of MeshModelFilters. More...
 
class  TypedMeshModelInterface
 
class  TypedNullOperationMeshModelFilterAdaptor
 Adapts a NullOperationMeshModelFilter to a TypedMeshModelFilter. More...
 
class  TypedScalarNodeStateFilterAdaptor
 Adapts a ScalarNodeStateFilter to a TypedMeshModelFilter. More...
 
class  Vector3d
 A vector or 3D point in space with useful operation support. More...
 
class  Vector3dGroup
 Object group containing three floating point numbers. More...
 
class  Vector3dGroupDegreesWidget
 
class  Vector3dGroupDegreesWidgetConnector
 Connects a Vector3dGroupDegreesWidget to a Vector3dGroup data object. More...
 
class  Vector3dGroupDegreesWidgetDesigner
 Qt Designer support for Vector3dGroupDegreesWidget. More...
 
class  Vector3dGroupDegreesWidgetFactory
 Widget factory for a Vector3dGroupDegreesWidget. More...
 
class  Vector3dGroupWidget
 
class  Vector3dGroupWidgetConnector
 Connects a Vector3dGroupWidget to a Vector3dGroup data object. More...
 
class  Vector3dGroupWidgetDesigner
 Qt Designer support for Vector3dGroupWidget. More...
 
class  Vector3dGroupWidgetFactory
 Widget factory for a Vector3dGroupWidget. More...
 
class  VectorNodeMapper
 Base class defining an interface for mapping a model's nodes to values. More...
 
class  VectorNodeStateMapper
 Node mapper returning a particular node state as its value. More...
 
class  VectorNodeStateMapperBuilder
 Generates a NodeStateMapper object. More...
 
class  VectorNodeTextureMapper
 Node mapper returning a particular node state as its value. More...
 
class  VectorNodeTextureMapperBuilder
 Generates a NodeStateMapper object. More...
 
struct  VectorStorage
 Storage policy for using a sorted vector. More...
 
struct  VectorStorageLess
 Sorting criteria for a sorted vector storage policy. More...
 
class  VectorToScalarArray3d
 Creates a Array3dScalar from a Array3dVector, allowing the user to select the method of conversion. More...
 
class  VolumeElement
 Defines a volume element class (ie a four-noded tetrahedral element). More...
 
class  VolumeElementList
 Class for storing and manipulating a list of VolumeElement objects. More...
 
class  VolumeFace
 Define a class representing a face of a tetra volume element. More...
 
class  VtkReaderOperation
 Provides an operation for reading vtk files. More...
 
class  VtkWriter
 Writes models in VTK ASCII format. More...
 
class  VtkWriterOperation
 Provides an operation for writing Vtk files. More...
 

Typedefs

using Array3dNullVector = DataAnalysis::Array3dNullTyped< Vector3d >
 
typedef DataAnalysis::Array3dTyped< Vector3dArray3dVector
 
typedef QMap< const ElementType::Type *, const ElementStateHandle * > ElementTypeToState
 
typedef std::pair< int, int > IndexMapping
 
using IndexMappings = std::vector< IndexMapping >
 
using int_type = MeshModelInterface::int_type
 
typedef std::map< long, Node * > LocalMapOfNodes
 
typedef QList< MeshModelFilter * > MeshModelFilterList
 
using NodeHandleIndexHash = QHash< NodeHandle, ItemHandle::size_type >
 
typedef QHash< NodeHandle, long > NodeIndexLookup
 
typedef uint OctreeIndex
 
using size_type = MeshModelInterface::size_type
 
typedef std::vector< StateInfoStateInfoArray
 
typedef Vector3d Vector3D
 

Enumerations

enum  { NO_TYPE = -1 , CIRCULAR_ARC = 100 , LINE = 110 , TRANSFORM_MATRIX = 124 }
 
enum  {
  INCHES = 1 , MM , PARAM_15 , FEET ,
  MILES , METRES , KILOMETRES , MILS ,
  MICRONS , CM , MICROINCHES
}
 
enum class  InspectorViewMode { ViewNodes , ViewElements , ViewAll }
 
enum  RangeInOut { WithinRange , OutsideRange }
 Defines if a range is to be used inclusive or exclusive. More...
 
enum  ShellElementTypes { UNDEFINED , TRI3 , QUAD4 }
 
enum  SmoothMeshMethod { SimpleLaplacian , ScaleDependentLaplacian }
 
enum  VectorMapping { Magnitude , X , Y , Z }
 Defines how to map a vector into a single value. More...
 
enum  VtkCellType {
  VTK_INVALID_CELLTYPE = -1 , VTK_UNKNOWN_CELLTYPE = 0 , VTK_POLY_VERTEX = 2 , VTK_LINE = 3 ,
  VTK_TRIANGLE = 5 , VTK_POLYGON = 6 , VTK_QUAD = 9 , VTK_TETRA = 10
}
 

Functions

CSIRO_MESH_API CSIRO::Mesh::MeshModelInterfaceallocateEfficientMeshModelInterface ()
 
static const std::string alphabet ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
 
static const std::string alphabet ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
 
static const std::string alphanumeric (alphabet+numeric)
 
static const std::string alphanumeric (alphabet+numeric)
 
bool approxEqual (const TransformMatrix &m1, const TransformMatrix &m2)
 
bool approxEqual (const Vector3d &v1, const Vector3d &v2, const double eps=CSIRO::Application::epsilon< double >())
 
Vector3d axisVector (int axis)
 
Vector3d AxisVector (int axis)
 
int BitMask (unsigned pos)
 
bool calculateElementCentroid (const MeshModelInterface &model, const ElementType::Type &type, const ElementHandle &element, Vector3d &result)
 
bool calculateElementNormal (const ElementType::Type &type, const QVector< Vector3d > &points, Vector3d &result)
 
bool calculateElementNormal (const MeshModelInterface &model, const ElementType::Type &type, const ElementHandle &element, Vector3d &result)
 
bool calculateNodeNormal (const MeshModelInterface &model, const NodeHandle &node, Vector3d &result)
 
bool calculateQuadrilateralNormal (const Vector3d &pos0, const Vector3d &pos1, const Vector3d &pos2, const Vector3d &pos3, Vector3d &result)
 
double calculateTriangleArea (const Vector3d &pos0, const Vector3d &pos1, const Vector3d &pos2)
 
bool calculateTriangleNormal (const Vector3d &pos0, const Vector3d &pos1, const Vector3d &pos2, Vector3d &result)
 
template<typename ScalarType >
ScalarType clamp (ScalarType v, ScalarType low, ScalarType high)
 
Vector3d closestOnShellToPoint (const Vector3d &pos, ShellElement &elem, int &pointType)
 
Vector3d ClosestOnShellToPoint (const Vector3d &pos, ShellElement &elem, int &pointType)
 
Vector3d computeCenter (const Node &node0, const Node &node1, const Node &node2, const Node &node3)
 
Vector3d computeCenter (const Vector3d &fourthPoint, const double *minorsD, const double *minorsX, const double *minorsY, const double *minorsZ)
 
Vector3d computeCenter (const Vector3d &p0, const Vector3d &p1, const Vector3d &p2, const Vector3d &p3)
 
Vector3d computeCenter (VolumeElement &elem)
 
void computeMinors (const double *row0, const double *row1, const double *row2, double *minors)
 
template<typename ContainerType >
void ContainerFlagSetter (ContainerType &container, unsigned flag, bool b=true)
 
double CosAngle (const Vector3d &t1, const Vector3d &t2)
 
Vector3d CrossProduct (const Vector3d &t1, const Vector3d &t2)
 
double discriminant (double a1, double b1, double a2, double b2)
 
double Discriminant (double a1, double b1, double a2, double b2)
 
double DotProduct (const Vector3d &t1, const Vector3d &t2)
 
static const std::string doubleSet (numeric+"+-.eE")
 
static const std::string doubleSet (numeric+"+-.eE")
 
template<typename T >
FaceIterator< T > FacesBegin (T &t)
 
template<typename T >
FaceIterator< T > FacesEnd (T &t)
 
void fillMinors (const Vector3d &p0, const Vector3d &p1, const Vector3d &p2, double *minorsD, double *minorsX, double *minorsY, double *minorsZ)
 
VolumeFacefindAttachedFace (const Node &node0, const Node &node1, const Node &node2)
 
ElementHandle getAttachedHexahedronFace (const MeshModelInterface &model, const ElementHandle &hexahedraElementHandle, int face, bool *handleFound, NodeHandleList *nodesOfAttachedHexaFace)
 
ElementHandle getAttachedTetrahedronFace (const MeshModelInterface &model, const ElementHandle &tetraElementHandle, int face, bool *handleFound, NodeHandleList *nodesOfAttachedTetraFace)
 
Vector3d getEulerAnglesFromNewZAxis (const Vector3d &newZ)
 
NodeHandleList getHexahedronFace (int face, const NodeHandleList &nodes)
 
template<typename T >
CSIRO_MESH_API const ListTraits< T >::ListType & getList (const MeshModel &model)
 Get the model's list for the T type objects, where T is a node or element type.
 
template<typename T >
const ListTraits< T >::ListType & getList (const MeshModel &model)
 Get the model's list for the T type objects, where T is a node or element type.
 
template<typename T >
CSIRO_MESH_API ListTraits< T >::ListType & getList (MeshModel &model)
 Get the model's list for the T type objects, where T is a node or element type.
 
template<typename T >
ListTraits< T >::ListType & getList (MeshModel &model)
 Get the model's list for the T type objects, where T is a node or element type.
 
void getNewZAxisFromEulerAngles (const Vector3d &euler, Vector3d &newZ, double &rotationAboutZ)
 
Vector3d getNodeProjectedToLine (const Vector3d &p, const Vector3d &v0, const Vector3d &v1)
 
Vector3d GetNodeProjectedToLine (const Vector3d &p, const Vector3d &v0, const Vector3d &v1)
 
Vector3d getNodeProjectedToLineSegment (const Vector3d &p, const Vector3d &v0, const Vector3d &v1)
 
Vector3d GetNodeProjectedToLineSegment (const Vector3d &p, const Vector3d &v0, const Vector3d &v1)
 
NodeHandle getOpposingTetrahedronNode (int face, const NodeHandleList &nodes)
 
bool getPlanesIntersect (const Vector3d &r0, const Vector3d &n0, const Vector3d &r1, const Vector3d &n1, Vector3d &p, Vector3d &v)
 
bool GetPlanesIntersect (const Vector3d &r0, const Vector3d &n0, const Vector3d &r1, const Vector3d &n1, Vector3d &p, Vector3d &v)
 
template<typename InterfaceType , typename StateHandleType , typename T >
bool getSimpleTypeRange (const InterfaceType &interface, const StateHandleType stateHandle, double &minimum, double &maximum)
 
NodeHandleList getTetrahedronFace (int face, const NodeHandleList &nodes)
 
static const std::string integerSet (numeric+"+-")
 
static const std::string integerSet (numeric+"+-")
 
CSIRO_MESH_API bool IsConvex (ShellElement &elem_A, ShellElement &elem_B, Node &node)
 
bool isConvexEdge (const Vector3d &elementNormalA, const Vector3d &elementNormalB, const Vector3d &nodePosA, const Vector3d &nodePosB)
 
bool isConvexEdge (ShellElement &elem_A, ShellElement &elem_B, Node &node)
 
bool IsOnTop (const Vector3d &node1, const Vector3d &node2)
 
bool linePlaneIntersect (const Vector3d &n0, const Vector3d &n1, const Vector3d &pPoint, const Vector3d &pNormal, Vector3d &intersect)
 
bool LinePlaneIntersect (const Vector3d &n0, const Vector3d &n1, const Vector3d &pPoint, const Vector3d &pNormal, Vector3d &intersect)
 
Vector3d linePlaneIntersection (const Line &line, const BoundingPlane &plane)
 
bool lineSegmentsIntersect (const Vector3d &a0, const Vector3d &a1, const Vector3d &b0, const Vector3d &b1)
 
bool LineSegmentsIntersect (const Vector3d &a0, const Vector3d &a1, const Vector3d &b0, const Vector3d &b1)
 
bool lineSegmentsIntersect (const Vector3d &a0, const Vector3d &a1, const Vector3d &b0, const Vector3d &b1, double &tA, double &tB)
 
bool LineSegmentsIntersect (const Vector3d &a0, const Vector3d &a1, const Vector3d &b0, const Vector3d &b1, double &tA, double &tB)
 
bool lineShellIntersect (const Vector3d &r0, const Vector3d &r1, const ShellElement &elem)
 
bool LineShellIntersect (const Vector3d &r0, const Vector3d &r1, const ShellElement &elem)
 
bool lineThroughSweptVolume (const Vector3d &n0, const Vector3d &n1, const ShellElement &elem, double aveElemShift)
 
bool LineThroughSweptVolume (const Vector3d &n0, const Vector3d &n1, const ShellElement &elem, double aveElemShift)
 
NodeHandle nextNodeHandle (const NodeHandleList &nodes, const NodeHandle &node)
 
static const std::string numeric ("0123456789")
 
static const std::string numeric ("0123456789")
 
OctreeIndex octreeNodeChildArrayIndex (unsigned x, unsigned y, unsigned z)
 
template<typename ScalarType >
OctreeIndex octreeNodeChildExists (const OctreeNode< ScalarType > &node, OctreeIndex childArrayIndex)
 
template<typename ScalarType >
OctreeIndex octreeNodeGetChild (const OctreeNode< ScalarType > &node, OctreeIndex childArrayIndex)
 
template<typename ScalarType >
bool octreeNodeIntersectsAABB (const OctreeNode< ScalarType > &node, const OctreeVector3< ScalarType > &aabbMin, const OctreeVector3< ScalarType > &aabbMax)
 
template<typename ScalarType >
bool octreeNodeIntersectsSphere (const OctreeNode< ScalarType > &node, const OctreeVector3< ScalarType > &pos, ScalarType radius)
 
template<typename ScalarType >
OctreeVector3< ScalarType > operator* (const OctreeVector3< ScalarType > &a, ScalarType b)
 
template<typename ScalarType >
OctreeVector3< ScalarType > operator+ (const OctreeVector3< ScalarType > &t1, const OctreeVector3< ScalarType > &t2)
 
template<typename ScalarType >
OctreeVector3< ScalarType > operator- (const OctreeVector3< ScalarType > &t1, const OctreeVector3< ScalarType > &t2)
 
QDataStream & operator<< (QDataStream &stream, const MeshModelInterface &mesh)
 
std::ostream & operator<< (std::ostream &output, const Vector3d &v)
 
QDataStream & operator>> (QDataStream &stream, MeshModelInterface &mesh)
 
bool pointInsideShellPlane (const Vector3d &n0, const ShellElement &elem)
 
bool PointInsideShellPlane (const Vector3d &n0, const ShellElement &elem)
 
bool pointInsideShellVolume (const Vector3d &n0, const ShellElement &elem, double aveElemShift)
 
bool PointInsideShellVolume (const Vector3d &n0, const ShellElement &elem, double aveElemShift)
 
NodeHandle prevNodeHandle (const NodeHandleList &nodes, const NodeHandle &node)
 
void projectLineToPlane (Vector3d &n0, Vector3d &n1, const Vector3d &pPoint, const Vector3d &pNormal)
 
void ProjectLineToPlane (Vector3d &n0, Vector3d &n1, const Vector3d &pPoint, const Vector3d &pNormal)
 
void projectLineToShellPlane (Vector3d &n0, Vector3d &n1, const ShellElement &elem)
 
void ProjectLineToShellPlane (Vector3d &n0, Vector3d &n1, const ShellElement &elem)
 
int projectPointToLineSegment (Vector3d &p, const Vector3d &v0, const Vector3d &v1)
 
int ProjectPointToLineSegment (Vector3d &p, const Vector3d &v0, const Vector3d &v1)
 
Vector3d projectPointToPlane (const Vector3d &p0, const Vector3d &pPoint, const Vector3d &pNormal)
 
Vector3d ProjectPointToPlane (const Vector3d &p0, const Vector3d &pPoint, const Vector3d &pNormal)
 
uint qHash (const CSIRO::Mesh::ElementHandle &key)
 
uint qHash (const CSIRO::Mesh::NodeHandle &key)
 
template<typename IteratorType >
void RangeFlagCopy (IteratorType begin, IteratorType end, unsigned flagFrom, unsigned flagTo)
 
template<typename IteratorType >
void RangeFlagSetter (IteratorType begin, IteratorType end, unsigned flag, bool b=true)
 
template<typename T >
readBinaryValue (QIODevice &file, bool bigEndian)
 
template<>
float readBinaryValue (QIODevice &file, bool bigEndian)
 
template<>
double readBinaryValue (QIODevice &file, bool bigEndian)
 
template<typename T >
readBinaryValue (std::ifstream &file, bool bigEndian)
 
template<>
float readBinaryValue (std::ifstream &file, bool bigEndian)
 
template<>
double readBinaryValue (std::ifstream &file, bool bigEndian)
 
Vector3d rotate (const Vector3d &pos, double preRotateAngle, const Vector3d &newZ)
 
Vector3d rotateAboutZ (const Vector3d &pos, double rotateAngle)
 
static double s_calcAngleBetweenStartAndEnd (IGESArc *arcIn)
 
static bool s_calcInteriorPoints (Vector3d pStart, double epsilon, int numSegs, double sectionAngle, std::vector< Vector3d > *interiorPoints, double arcRadius)
 
double ScalarTripleProduct (const Vector3d &t1, const Vector3d &t2, const Vector3d &t3)
 
double SinAngle (const Vector3d &t1, const Vector3d &t2)
 
bool solve2eqns (double a1, double b1, double rhs1, double a2, double b2, double rhs2, double &x, double &y)
 
bool Solve2eqns (double a1, double b1, double rhs1, double a2, double b2, double rhs2, double &x, double &y)
 
long splitLongEdges (MeshModel &model, double maxEdgeLength, bool splitSlowly)
 
Vector3d tilt (const Vector3d &pos, const Vector3d &newZ)
 
void Tokenize (const std::string &str, std::vector< std::string > &tokens, const std::string &delimiters=" ")
 
Vector3d UnitVector (const Vector3d &v)
 

Variables

const OctreeIndex InvalidOctreeIndex = std::numeric_limits<OctreeIndex>::max()
 

Detailed Description

The Mesh namespace provides 3D mesh model data structures. Only basic algorithms are supplied to manipulate a mesh model, with more complex algorithms being supplied in separate modules.

Typedef Documentation

◆ Array3dNullVector

◆ Array3dVector

◆ ElementTypeToState

◆ IndexMapping

typedef std::pair<int, int> IndexMapping

◆ IndexMappings

using IndexMappings = std::vector<IndexMapping>

◆ int_type

◆ LocalMapOfNodes

typedef std::map<long, Node*> LocalMapOfNodes

◆ MeshModelFilterList

◆ NodeHandleIndexHash

A index lookup based on NodeHandle keys if NodeHandleIndexLookup can't be used

See also
NodeHandleIndexLookup

◆ NodeIndexLookup

typedef QHash<NodeHandle, long> NodeIndexLookup

◆ OctreeIndex

typedef uint OctreeIndex

◆ size_type

◆ StateInfoArray

typedef std::vector<StateInfo> StateInfoArray

Convenience typedef for a vector used to hold an array of state info.

◆ Vector3D

typedef Vector3d Vector3D

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
NO_TYPE 
CIRCULAR_ARC 
LINE 
TRANSFORM_MATRIX 

◆ anonymous enum

anonymous enum
Enumerator
INCHES 
MM 
PARAM_15 
FEET 
MILES 
METRES 
KILOMETRES 
MILS 
MICRONS 
CM 
MICROINCHES 

◆ InspectorViewMode

enum class InspectorViewMode
strong
Enumerator
ViewNodes 
ViewElements 
ViewAll 

◆ RangeInOut

enum RangeInOut
Enumerator
WithinRange 
OutsideRange 

◆ ShellElementTypes

Enumerator
UNDEFINED 
TRI3 
QUAD4 

◆ SmoothMeshMethod

Enumerator
SimpleLaplacian 
ScaleDependentLaplacian 

◆ VectorMapping

The values of this enumerated type specify what strategy to use when mapping a vector to a scalar value.

Enumerator
Magnitude 

Map the vector's magnitude.

Map the vector's X component. The Y and Z components are ignored.

Map the vector's Y component. The X and Z components are ignored.

Map the vector's Z component. The X and Y components are ignored.

◆ VtkCellType

Enumerator
VTK_INVALID_CELLTYPE 
VTK_UNKNOWN_CELLTYPE 
VTK_POLY_VERTEX 
VTK_LINE 
VTK_TRIANGLE 
VTK_POLYGON 
VTK_QUAD 
VTK_TETRA 

Function Documentation

◆ allocateEfficientMeshModelInterface()

CSIRO_MESH_API CSIRO::Mesh::MeshModelInterface * allocateEfficientMeshModelInterface ( )

◆ alphabet() [1/2]

static const std::string alphabet ( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"  )
static

◆ alphabet() [2/2]

static const std::string alphabet ( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"  )
static

◆ alphanumeric() [1/2]

static const std::string alphanumeric ( alphabet numeric)
static

◆ alphanumeric() [2/2]

static const std::string alphanumeric ( alphabet numeric)
static

◆ approxEqual() [1/2]

bool approxEqual ( const TransformMatrix m1,
const TransformMatrix m2 
)
inline
Parameters
m1First matrix for comparison
m2Second matrix for comparison
Returns
True if m is identical to this matrix, ignoring rounding errors.

Compare two Transform Matrices using a floating-point tolerance check, rather than using a straight binary comparison.

◆ approxEqual() [2/2]

bool approxEqual ( const Vector3d v1,
const Vector3d v2,
const double  eps = CSIRO::Application::epsilon<double>() 
)
inline

◆ axisVector()

Vector3d axisVector ( int  axis)
inline

◆ AxisVector()

Vector3d AxisVector ( int  axis)
inline

◆ BitMask()

int BitMask ( unsigned  pos)
inline

◆ calculateElementCentroid()

CSIRO_MESH_API bool calculateElementCentroid ( const MeshModelInterface model,
const ElementType::Type type,
const ElementHandle element,
Vector3d result 
)

Calculate the centroid of an element of a given element type.

◆ calculateElementNormal() [1/2]

CSIRO_MESH_API bool calculateElementNormal ( const ElementType::Type type,
const QVector< Vector3d > &  points,
Vector3d result 
)

◆ calculateElementNormal() [2/2]

CSIRO_MESH_API bool calculateElementNormal ( const MeshModelInterface model,
const ElementType::Type type,
const ElementHandle element,
Vector3d result 
)

Calculate the element normal for ElementType::Tri or ElementType::Quad

◆ calculateNodeNormal()

CSIRO_MESH_API bool calculateNodeNormal ( const MeshModelInterface model,
const NodeHandle node,
Vector3d result 
)

The node normal is calculated as an angle-weighted average of the attached tri, quad and tetrahedron normals. The angle weighting is achieved by multiplying each normal by the vertex angle formed at this node. When the node normal vector is scaled to unit length, the angle-weighting has already been conveniently incorporated.

◆ calculateQuadrilateralNormal()

CSIRO_MESH_API bool calculateQuadrilateralNormal ( const Vector3d pos0,
const Vector3d pos1,
const Vector3d pos2,
const Vector3d pos3,
Vector3d result 
)

The normal is an area-weighted average of the four cross-products (i.e. remove a node and generate the cross-product for the remaining three). This is necessary because quad elements can be warped, so we cannot just take any three nodes to find the element normal. The area-weighting is a natural part of using the cross-product and sensibly weights each of the normals.

The normal vector is always of unit length.

◆ calculateTriangleArea()

CSIRO_MESH_API double calculateTriangleArea ( const Vector3d pos0,
const Vector3d pos1,
const Vector3d pos2 
)

◆ calculateTriangleNormal()

CSIRO_MESH_API bool calculateTriangleNormal ( const Vector3d pos0,
const Vector3d pos1,
const Vector3d pos2,
Vector3d result 
)

A check is made to see if the normal appears to have flipped its direction. Some algorithms rely on this to detect severe local distortions in the mesh between iterations.

The normal vector is always of unit length.

◆ clamp()

ScalarType clamp ( ScalarType  v,
ScalarType  low,
ScalarType  high 
)
inline

◆ closestOnShellToPoint()

CSIRO_IMPORTSPEC Vector3d closestOnShellToPoint ( const Vector3d pos,
ShellElement elem,
int &  pointType 
)

Free function for finding the point on elem that is closest to pos.

Returns
The closest point on elem to pos. Upon exit, the value of pointType will also be set according to where on elem this closest point is located. A value of zero indicates an interior point. A positive number indicates a vertex, with the number being one more than the index into the elem->nodes array. A negative number indicates an edge, with the number being the negative of the index into the elem->nodes array for the start of the edge (again offset by one).

◆ ClosestOnShellToPoint()

Vector3d ClosestOnShellToPoint ( const Vector3d pos,
ShellElement elem,
int &  pointType 
)
inline

◆ computeCenter() [1/4]

Vector3d computeCenter ( const Node node0,
const Node node1,
const Node node2,
const Node node3 
)
inline

◆ computeCenter() [2/4]

Vector3d computeCenter ( const Vector3d fourthPoint,
const double *  minorsD,
const double *  minorsX,
const double *  minorsY,
const double *  minorsZ 
)
inline

◆ computeCenter() [3/4]

Vector3d computeCenter ( const Vector3d p0,
const Vector3d p1,
const Vector3d p2,
const Vector3d p3 
)
inline

◆ computeCenter() [4/4]

Vector3d computeCenter ( VolumeElement elem)
inline

◆ computeMinors()

void computeMinors ( const double *  row0,
const double *  row1,
const double *  row2,
double *  minors 
)
inline

◆ ContainerFlagSetter()

void ContainerFlagSetter ( ContainerType &  container,
unsigned  flag,
bool  b = true 
)
inline
Parameters
containerThe container whose contents should have their flags set.
flagWhat flag to set.
bThe value to assign to the flag for each object.

For all objects in the specified container, set their flag to the value b. It is assumed that container is a NumberedObjectList of some kind.

See also
RangeFlagSetter

◆ CosAngle()

double CosAngle ( const Vector3d t1,
const Vector3d t2 
)
inline

◆ CrossProduct()

Vector3d CrossProduct ( const Vector3d t1,
const Vector3d t2 
)
inline

◆ discriminant()

double discriminant ( double  a1,
double  b1,
double  a2,
double  b2 
)
inline
Returns
The discriminant of the equation:

\[ \begin{array}{rcl}
    a_1 x + b_1 y  &=& rhs_1
    a_2 x + b_2 y  &=& rhs_2
    \end{array}
\]

Warning
Inlining of this function has been observed to have implications for lineSegmentsIntersect(). Read the comments for that function.

◆ Discriminant()

double Discriminant ( double  a1,
double  b1,
double  a2,
double  b2 
)
inline

◆ DotProduct()

double DotProduct ( const Vector3d t1,
const Vector3d t2 
)
inline

◆ doubleSet() [1/2]

static const std::string doubleSet ( numeric+"+-.eE"  )
static

◆ doubleSet() [2/2]

static const std::string doubleSet ( numeric+"+-.eE"  )
static

◆ FacesBegin()

FaceIterator< T > FacesBegin ( T &  t)
inline

◆ FacesEnd()

FaceIterator< T > FacesEnd ( T &  t)
inline

◆ fillMinors()

void fillMinors ( const Vector3d p0,
const Vector3d p1,
const Vector3d p2,
double *  minorsD,
double *  minorsX,
double *  minorsY,
double *  minorsZ 
)
inline

◆ findAttachedFace()

CSIRO_MESH_API VolumeFace * findAttachedFace ( const Node node0,
const Node node1,
const Node node2 
)

◆ getAttachedHexahedronFace()

CSIRO_MESH_API ElementHandle getAttachedHexahedronFace ( const MeshModelInterface model,
const ElementHandle hexahedraElementHandle,
int  face,
bool *  handleFound,
NodeHandleList *  nodesOfAttachedHexaFace 
)

◆ getAttachedTetrahedronFace()

CSIRO_MESH_API ElementHandle getAttachedTetrahedronFace ( const MeshModelInterface model,
const ElementHandle tetraElementHandle,
int  face,
bool *  handleFound,
NodeHandleList *  nodesOfAttachedTetraFace 
)

Will return an invalid handle if no attachment information exisits for ElementType::Tetrahedron

◆ getEulerAnglesFromNewZAxis()

Vector3d getEulerAnglesFromNewZAxis ( const Vector3d newZ)
inline

◆ getHexahedronFace()

CSIRO_MESH_API NodeHandleList getHexahedronFace ( int  face,
const NodeHandleList &  nodes 
)

◆ getList() [1/4]

CSIRO_MESH_API const ListTraits< T >::ListType & getList ( const MeshModel model)
inline

◆ getList() [2/4]

const ListTraits< T >::ListType & getList ( const MeshModel model)
inline

◆ getList() [3/4]

CSIRO_MESH_API ListTraits< T >::ListType & getList ( MeshModel model)
inline

◆ getList() [4/4]

ListTraits< T >::ListType & getList ( MeshModel model)
inline

◆ getNewZAxisFromEulerAngles()

void getNewZAxisFromEulerAngles ( const Vector3d euler,
Vector3d newZ,
double &  rotationAboutZ 
)
inline

◆ getNodeProjectedToLine()

Vector3d getNodeProjectedToLine ( const Vector3d p,
const Vector3d v0,
const Vector3d v1 
)
inline
Parameters
pThe point to project to the line
v0Start of line
v1End of line
Returns
The point p projected onto the line defined by the end points v0 and v1. This point could be outside the extent of the line segment.
See also
getNodeProjectedToLineSegment()

◆ GetNodeProjectedToLine()

Vector3d GetNodeProjectedToLine ( const Vector3d p,
const Vector3d v0,
const Vector3d v1 
)
inline

◆ getNodeProjectedToLineSegment()

Vector3d getNodeProjectedToLineSegment ( const Vector3d p,
const Vector3d v0,
const Vector3d v1 
)
inline
Parameters
pThe point to project to the line segment
v0Start of line
v1End of line
Returns
The point p projected onto the line defined by the end points v0 and v1. Unlike getNodeProjectedToLine(), this point will be restricted to the extent of the line segment.
See also
getNodeProjectedToLine(), projectPointToLineSegment()

◆ GetNodeProjectedToLineSegment()

Vector3d GetNodeProjectedToLineSegment ( const Vector3d p,
const Vector3d v0,
const Vector3d v1 
)
inline

◆ getOpposingTetrahedronNode()

CSIRO_MESH_API NodeHandle getOpposingTetrahedronNode ( int  face,
const NodeHandleList &  nodes 
)
Parameters
faceThe index of the face.
nodesThe nodes of the mesh to which the face belongs.

Returns the node of the tetrahedron not in the specific face, that is, the node opposing that face.

◆ getPlanesIntersect()

bool getPlanesIntersect ( const Vector3d r0,
const Vector3d n0,
const Vector3d r1,
const Vector3d n1,
Vector3d p,
Vector3d v 
)
inline

This function finds the line of intersection of two planes. The two planes are defined by the point, normal pairs (r0,n0) and (r1,n1) and the line of intersection is returned in p and v. The line of intersection is a parametric equation of the form:

\[ r = p + tv \]

Relevant equations:

\[ \begin{array}{lrcl}
    \text{Equation of a plane:} &  n \dot r &=& n \dot r_0
    \text{Equation of a line:}  &         r &=& p + t v
    \end{array}
  \]

At intersection of two planes, the line of intersection is parallel to the cross product of the planes' normal vectors. This can be seen by considering that the line must lie on both planes, and must therefore be normal to both planes' normal vectors. The cross product finds exactly this line as a vector, the magnitude of which is unimportant to us here.

To complete the definition of the line, we need a point on it. This requires more care to handle special cases, such as planes orthogonal to one of the xyz axes. The approach taken is to set one of x, y or z to zero and compute the other two by solving two simultaneous equations generated from the two planes' equations. We test to make sure our choice of which of x, y or z to set to zero is valid for both planes.

Returns
True if there is an intersection, or if the two planes are parallel then returns false.

◆ GetPlanesIntersect()

bool GetPlanesIntersect ( const Vector3d r0,
const Vector3d n0,
const Vector3d r1,
const Vector3d n1,
Vector3d p,
Vector3d v 
)
inline

◆ getSimpleTypeRange()

bool getSimpleTypeRange ( const InterfaceType &  interface,
const StateHandleType  stateHandle,
double &  minimum,
double &  maximum 
)

◆ getTetrahedronFace()

CSIRO_MESH_API NodeHandleList getTetrahedronFace ( int  face,
const NodeHandleList &  nodes 
)
Returns
The triangle face of a tetrahedron

◆ integerSet() [1/2]

static const std::string integerSet ( numeric+"+-"  )
static

◆ integerSet() [2/2]

static const std::string integerSet ( numeric+"+-"  )
static

◆ IsConvex()

CSIRO_MESH_API bool IsConvex ( ShellElement elem_A,
ShellElement elem_B,
Node node 
)
inline

◆ isConvexEdge() [1/2]

CSIRO_MESH_API bool isConvexEdge ( const Vector3d elementNormalA,
const Vector3d elementNormalB,
const Vector3d nodePosA,
const Vector3d nodePosB 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ isConvexEdge() [2/2]

CSIRO_MESH_API bool isConvexEdge ( ShellElement elem_A,
ShellElement elem_B,
Node node 
)
Parameters
elem_AFirst element (must be attached to node)
elem_BSecond element (must be attached to node)
nodeOne of the nodes shared by the two elements (see the pre-condition for exactly which node).
Returns
True if the element pair creates a convex edge.
Precondition
Both elem_A and elem_B must share an edge. The edge shared by elem_A and elem_B must be defined by the next node after node in elem_A being the other node of the shared edge. The node ordering for a shell element obeys the right-hand rule, with the shell's normal vector in the direction of the thumb and the nodes ordered anti-clockwise following the direction indicated by the fingers. *

◆ IsOnTop()

bool IsOnTop ( const Vector3d node1,
const Vector3d node2 
)

◆ linePlaneIntersect()

bool linePlaneIntersect ( const Vector3d n0,
const Vector3d n1,
const Vector3d pPoint,
const Vector3d pNormal,
Vector3d intersect 
)
inline

This function determines if the line from n0 to n1 passes through the plane defined by the point pPoint and normal vector pNormal.

Notation:

\[ \begin{array}{lrcl}
    \text{Equation of a plane:} & pNormal \dot r &=& pNormal \dot pPoint
    \text{Equation of a line:}  &              r &=& n_0 + t(n_1 - n_0)
    \end{array}
  \]

At intersection of line and plane:

\[ \begin{array}{rcl}
  pNormal \dot (n_0 + t(n_1 - n_0) &=& pNormal \dot pPoint
       t(pNormal \dot (n_1 - n_0)) &=& pNormal \dot (pPoint - n_0)
                                 t &=& \frac{pNormal \dot (pPoint - n_0)}{pNormal \dot (n_1 - n_0)}
  \end{array}
  \]

If the line segment n0–n1 intersects the plane, then 0 <= t <= 1 and the point of intersection is trivially obtained from the equation of a line, above.

Returns
True if there is an intersection, which will also cause the intersection point to be stored in intersect. If there is no intersection, intersect is left unchanged.

◆ LinePlaneIntersect()

bool LinePlaneIntersect ( const Vector3d n0,
const Vector3d n1,
const Vector3d pPoint,
const Vector3d pNormal,
Vector3d intersect 
)
inline

◆ linePlaneIntersection()

Vector3d linePlaneIntersection ( const Line line,
const BoundingPlane plane 
)
inline
Parameters
lineThe line intersecting the plane
planeThe plane being intersected

Calculates the point of intersection between a ray and a plane. The ray is defined as:

r(t) = p + v * t

And the plane (point q and normal n) as:

n . (q - x) = 0

So substituting in the ray equation for x, we can find t:

t = [n . (q - p)] / (n . v)

Once we have t, we can plug it back in to r(t) to find our point x.

◆ lineSegmentsIntersect() [1/2]

bool lineSegmentsIntersect ( const Vector3d a0,
const Vector3d a1,
const Vector3d b0,
const Vector3d b1 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Convenience function for when you just want to know if two lines intersect but are not interested in the intersection point.

◆ LineSegmentsIntersect() [1/2]

bool LineSegmentsIntersect ( const Vector3d a0,
const Vector3d a1,
const Vector3d b0,
const Vector3d b1 
)
inline

◆ lineSegmentsIntersect() [2/2]

bool lineSegmentsIntersect ( const Vector3d a0,
const Vector3d a1,
const Vector3d b0,
const Vector3d b1,
double &  tA,
double &  tB 
)
inline

Determines if two line segments intersect. It is assumed that the two lines are in the same plane, which is the same as assuming that if both lines were extended indefinitely, they would actually intersect at some point. Note that if the lines are parallel, they will be deemed as not intersecting, even if they are coincident.

Define two lines parametrically as:

\[ \begin{array}{rcl}
      a &=& a_0 x + t_A(a_1 - a_0)
      b &=& b_0 x + t_B(b_1 - b_0)
      \end{array}
  \]

At the point of intersection of lines A and B, the following holds true:

\[ a_0 + t_A(a_1 - a_0) = b_0 + t_B(b_1 - b_0) \]

Since this is a vector equation, there are three equations but only two unknowns. The component form of the above equation expands to:

\[ a_{0_i} + t_A(a_{1_i} - a_{0_i}) = b_{0_i} + t_B(b_{1_i} - b_{0_i}) \]

\[ \begin{array}{rcl}
    (a_{1_x} - a_{0_x})t_A - (b_{1_x} - b_{0_x})t_B &=& b_{0_x} - a_{0_x}
    (a_{1_y} - a_{0_y})t_A - (b_{1_y} - b_{0_y})t_B &=& b_{0_y} - a_{0_y}
    (a_{1_z} - a_{0_z})t_A - (b_{1_z} - b_{0_z})t_B &=& b_{0_z} - a_{0_z}
    \end{array}
  \]

We have assumed that A and B are on the same plane, so one of the three equations is redundant. Put another way, we must discard one of the equations, but we have to make sure we aren't left with two dependent equations. The safest way to handle this is look for the combination of equations which gives the best discriminant. For the first two equations, this would be:

\[ discr = | (a_{1_x} - a_{0_x})(b_{0_y} - b_{1_y}) - (b_{0_x} - b_{1_x})(a_{1_y} - a_{0_y}) | \]

The pair of equations with the highest discr values are the best choice. If all discriminants are small, then the lines are most likely parallel.

Once two suitable equations are found, we solve to get tA and tB. If the following two conditions are satisfied:

\[ \begin{array}{rcccl}
      0 &<=& tA &<=& 1
      0 &<=& tB &<=& 1
      \end{array}
  \]

then the two line segments intersect.

Warning
This function was originally written slightly differently. It was found that the g++ compiler was optimizing the code in a suspect way, leading to erroneous behaviour only when the code was compiled with optimization turned on. Specifically, the error would only arise when discriminant() was declared as an inline function. The current arrangement allows discriminant() to be inline without giving the optimization errors just mentioned. Be careful if you change anything in this function!
Returns
True if the line segments intersect. tA and tB give the parametric values for the two lines at their point of intersection (but will be left unaltered if the lines are parallel).

◆ LineSegmentsIntersect() [2/2]

bool LineSegmentsIntersect ( const Vector3d a0,
const Vector3d a1,
const Vector3d b0,
const Vector3d b1,
double &  tA,
double &  tB 
)
inline

◆ lineShellIntersect()

CSIRO_IMPORTSPEC bool lineShellIntersect ( const Vector3d r0,
const Vector3d r1,
const ShellElement elem 
)

This function determines if the line from r0 to r1 cuts through any edge of the shell element, elem. It is assumed that r0–r1 is on the same plane as elem. If you can't guarantee this, call ProjectLineToElemPlane first.

Returns
True if there is an intersection.

◆ LineShellIntersect()

bool LineShellIntersect ( const Vector3d r0,
const Vector3d r1,
const ShellElement elem 
)
inline

◆ lineThroughSweptVolume()

CSIRO_IMPORTSPEC bool lineThroughSweptVolume ( const Vector3d n0,
const Vector3d n1,
const ShellElement elem,
double  aveElemShift 
)
Returns
True if n0--n1 passes through the volume created by sweeping the shell element elem a distance of aveElemShift in the direction opposite to the normal of elem.

◆ LineThroughSweptVolume()

bool LineThroughSweptVolume ( const Vector3d n0,
const Vector3d n1,
const ShellElement elem,
double  aveElemShift 
)
inline

◆ nextNodeHandle()

CSIRO_MESH_API NodeHandle nextNodeHandle ( const NodeHandleList &  nodes,
const NodeHandle node 
)
Returns
the next handle in the list after node

◆ numeric() [1/2]

static const std::string numeric ( "0123456789"  )
static

◆ numeric() [2/2]

static const std::string numeric ( "0123456789"  )
static

◆ octreeNodeChildArrayIndex()

OctreeIndex octreeNodeChildArrayIndex ( unsigned  x,
unsigned  y,
unsigned  z 
)
inline
Returns
Index into OctreeNode::children_[]

◆ octreeNodeChildExists()

OctreeIndex octreeNodeChildExists ( const OctreeNode< ScalarType > &  node,
OctreeIndex  childArrayIndex 
)

◆ octreeNodeGetChild()

OctreeIndex octreeNodeGetChild ( const OctreeNode< ScalarType > &  node,
OctreeIndex  childArrayIndex 
)
Returns
Index into Octree::nodes_[]

◆ octreeNodeIntersectsAABB()

bool octreeNodeIntersectsAABB ( const OctreeNode< ScalarType > &  node,
const OctreeVector3< ScalarType > &  aabbMin,
const OctreeVector3< ScalarType > &  aabbMax 
)
inline

◆ octreeNodeIntersectsSphere()

bool octreeNodeIntersectsSphere ( const OctreeNode< ScalarType > &  node,
const OctreeVector3< ScalarType > &  pos,
ScalarType  radius 
)
inline

◆ operator*()

OctreeVector3< ScalarType > operator* ( const OctreeVector3< ScalarType > &  a,
ScalarType  b 
)
inline

◆ operator+()

OctreeVector3< ScalarType > operator+ ( const OctreeVector3< ScalarType > &  t1,
const OctreeVector3< ScalarType > &  t2 
)
inline

◆ operator-()

OctreeVector3< ScalarType > operator- ( const OctreeVector3< ScalarType > &  t1,
const OctreeVector3< ScalarType > &  t2 
)
inline

◆ operator<<() [1/2]

QDataStream & operator<< ( QDataStream &  stream,
const MeshModelInterface mesh 
)
Parameters
streamThe output stream to write to
meshThe mesh the data is being streamed from
Returns
stream The output stream that was written to, allows chaining of calls.

Global output streaming operator for MeshModelInterface (binary data)

◆ operator<<() [2/2]

std::ostream & operator<< ( std::ostream &  output,
const Vector3d v 
)
inline

◆ operator>>()

QDataStream & operator>> ( QDataStream &  stream,
MeshModelInterface mesh 
)
Parameters
streamThe stream we are reading mesh data from
meshThe mesh the data is going to be stored in
Returns
stream The output stream that we read from, allows chaining of calls.

Global input streaming operator for MeshModelInterface (binary data)

◆ pointInsideShellPlane()

CSIRO_IMPORTSPEC bool pointInsideShellPlane ( const Vector3d n0,
const ShellElement elem 
)

This function determines if the point n0 is on the interior of the shell element elem.

Precondition
It is assumed that n0 is actually on the plane of the element elem.
Returns
True if n0 is on the interior of the element or on the element's edge.

◆ PointInsideShellPlane()

bool PointInsideShellPlane ( const Vector3d n0,
const ShellElement elem 
)
inline

◆ pointInsideShellVolume()

bool pointInsideShellVolume ( const Vector3d n0,
const ShellElement elem,
double  aveElemShift 
)
inline

This function determines if the point n0 is inside the volume formed by dragging the shell element elem from its current position along its negative normal direction for a distance of aveElemShift. The negative direction is used because this function is likely to be called after elem has already been shifted, so we usually want to see if the element passed through point p0.

Returns
True if n0 is inside the volume (including on the edge/surface of it).

◆ PointInsideShellVolume()

bool PointInsideShellVolume ( const Vector3d n0,
const ShellElement elem,
double  aveElemShift 
)
inline

◆ prevNodeHandle()

CSIRO_MESH_API NodeHandle prevNodeHandle ( const NodeHandleList &  nodes,
const NodeHandle node 
)
Returns
the previous handle in the list after node

◆ projectLineToPlane()

void projectLineToPlane ( Vector3d n0,
Vector3d n1,
const Vector3d pPoint,
const Vector3d pNormal 
)
inline

This function projects the line n0--n1 onto the plane defined by pPoint and pNormal. The two points n0 and n1 are modified in place.

Precondition
pNormal must be a unit vector.

◆ ProjectLineToPlane()

void ProjectLineToPlane ( Vector3d n0,
Vector3d n1,
const Vector3d pPoint,
const Vector3d pNormal 
)
inline

◆ projectLineToShellPlane()

void projectLineToShellPlane ( Vector3d n0,
Vector3d n1,
const ShellElement elem 
)
inline

This function projects the line n0--n1 onto the plane of the shell element elem. Note that both n0 and n1 are modified by this function.

◆ ProjectLineToShellPlane()

void ProjectLineToShellPlane ( Vector3d n0,
Vector3d n1,
const ShellElement elem 
)
inline

◆ projectPointToLineSegment()

int projectPointToLineSegment ( Vector3d p,
const Vector3d v0,
const Vector3d v1 
)
inline
Parameters
pThe point to project to the line segment
v0Start of line
v1End of line

The point p will be projected onto the line defined by the end points v0 and v1. Unlike getNodeProjectedToLine(), this point will be restricted to the extent of the line segment.

Returns
0 if the projected point is at v0, 1 if it is at v1 and -1 if the projected point is somewhere between v0 and v1.
See also
getNodeProjectedToLine()

◆ ProjectPointToLineSegment()

int ProjectPointToLineSegment ( Vector3d p,
const Vector3d v0,
const Vector3d v1 
)
inline

◆ projectPointToPlane()

Vector3d projectPointToPlane ( const Vector3d p0,
const Vector3d pPoint,
const Vector3d pNormal 
)
inline

This function projects the point p0 onto the plane defined by pPoint and pNormal. Note that pNormal must be a unit vector.

Relevant equations:

\[ \begin{array}{lrcl}
    \text{Equation of a plane:} &  p_{\text{normal}} \dot r &=& p_{\text{normal}} \dot p_{\text{point}}
    \text{Vector of point on plane to p0:}  &           b_0 &=& p_0 - p_{\text{point}}
    \end{array}
  \]

\[ \begin{array}{rl}
    p_{\text{normal}} & \text{is a unit length normal}
    p_{\text{point}}  & \text{is any point on the plane}
    \end{array}
  \]

To project a point onto a plane, we first find the distance from the plane to the point. This is most easily done using a projection of b0 onto the plane's normal vector.

\[ D_0 = \frac{p_{\text{normal}} \dot b_0}{|p_{\text{normal}}|} \]

D0 will be positive if the plane's normal vector points to the side of the plane containing n0.

In this case, we enforce the assumption that pNormal is a unit vector, so the expression reduces down to:

\[ D_0 = p_{\text{normal}} \dot b_0 \]

The new point on the plane can then be found from vector math

\[ \begin{array}{rcl}
     r_0 &=& p_0 - D_0 p_{\text{normal}}
         &=& p_0 - ((p_{\text{normal}} \dot b_0) * p_{\text{normal}})
         &=& p_0 - ((p_{\text{normal}} \dot (p_0 - p_{\text{point}}) p_{\text{normal}})
     \end{array}
  \]

Returns
The projected point.

◆ ProjectPointToPlane()

Vector3d ProjectPointToPlane ( const Vector3d p0,
const Vector3d pPoint,
const Vector3d pNormal 
)
inline

◆ qHash() [1/2]

uint qHash ( const CSIRO::Mesh::ElementHandle key)
inline

◆ qHash() [2/2]

uint qHash ( const CSIRO::Mesh::NodeHandle key)
inline

Needed for QHash, QSet etc.

◆ RangeFlagCopy()

void RangeFlagCopy ( IteratorType  begin,
IteratorType  end,
unsigned  flagFrom,
unsigned  flagTo 
)
inline
Parameters
beginStart of range to set flags for.
endOne-past-end of range to set flags for.
flagFromWhat flag to copy from.
flagToWhat flag to copy to.

For all objects in the specified range, set their flagTo flag to the value of the flagFrom flag. It is assumed that the begin and end iterators belong to a NumberedObjectList container.

See also
RangeFlagSetter

◆ RangeFlagSetter()

void RangeFlagSetter ( IteratorType  begin,
IteratorType  end,
unsigned  flag,
bool  b = true 
)
inline
Parameters
beginStart of range to set flags for.
endOne-past-end of range to set flags for.
flagWhat flag to set.
bThe value to assign to the flag for each object.

For all objects in the specified range, set their flag to the value b. It is assumed that the begin and end iterators belong to a NumberedObjectList container.

See also
RangeFlagCopy, ContainerFlagSetter

◆ readBinaryValue() [1/6]

T readBinaryValue ( QIODevice &  file,
bool  bigEndian 
)
inline

◆ readBinaryValue() [2/6]

float readBinaryValue ( QIODevice &  file,
bool  bigEndian 
)
inline

◆ readBinaryValue() [3/6]

double readBinaryValue ( QIODevice &  file,
bool  bigEndian 
)
inline

◆ readBinaryValue() [4/6]

T readBinaryValue ( std::ifstream &  file,
bool  bigEndian 
)
inline

◆ readBinaryValue() [5/6]

float readBinaryValue ( std::ifstream &  file,
bool  bigEndian 
)
inline

◆ readBinaryValue() [6/6]

double readBinaryValue ( std::ifstream &  file,
bool  bigEndian 
)
inline

◆ rotate()

Vector3d rotate ( const Vector3d pos,
double  preRotateAngle,
const Vector3d newZ 
)
inline

◆ rotateAboutZ()

Vector3d rotateAboutZ ( const Vector3d pos,
double  rotateAngle 
)
inline

◆ s_calcAngleBetweenStartAndEnd()

static double s_calcAngleBetweenStartAndEnd ( IGESArc arcIn)
static

◆ s_calcInteriorPoints()

static bool s_calcInteriorPoints ( Vector3d  pStart,
double  epsilon,
int  numSegs,
double  sectionAngle,
std::vector< Vector3d > *  interiorPoints,
double  arcRadius 
)
static

◆ ScalarTripleProduct()

double ScalarTripleProduct ( const Vector3d t1,
const Vector3d t2,
const Vector3d t3 
)
inline

◆ SinAngle()

double SinAngle ( const Vector3d t1,
const Vector3d t2 
)
inline

◆ solve2eqns()

bool solve2eqns ( double  a1,
double  b1,
double  rhs1,
double  a2,
double  b2,
double  rhs2,
double &  x,
double &  y 
)
inline

Solves a pair of linear simultaneous equations. The solution is returned in x and y.

\[ \begin{array}{rcl}
    a_1 x + b_1 y  &=& rhs_1
    a_2 x + b_2 y  &=& rhs_2
    \end{array}
\]

Returns
True if the equations could be solved. If the two equations are not independent, it will return false and x and y will be left unchanged.

◆ Solve2eqns()

bool Solve2eqns ( double  a1,
double  b1,
double  rhs1,
double  a2,
double  b2,
double  rhs2,
double &  x,
double &  y 
)
inline

◆ splitLongEdges()

CSIRO_MESH_API long splitLongEdges ( MeshModel model,
double  maxEdgeLength,
bool  splitSlowly 
)
Parameters
modelThe model for which all long edges of shell elements should be split.
maxEdgeLengthThe maximum allowable edge length. Element edges longer than this will be split recursively until they are no greater than this threshold.
splitSlowlyIf this is set to true, the edge splits will not act recursively, but rather only potentially split the elements that exist when the function is called. This can have the effect of slowing down the edge splitting phase of things like MeshCleaner::conformMesh().

Split all long edges in model's shell element list. This process continues to split new elements too until all element lengths are less than the currently set target maximum edge length.

Returns
The number of elements that had edges split. If an element is split more than once (ie it has sides split, and the new elements created are split further), then each element split is counted, not just the original element. When multiple sides of the same element are split, it counts as one.
Postcondition
The attached element lists for each node will have been re-sorted by calling sortAttachedShellElements() for each node. The longest element edge is guaranteed to be no greater than maxEdgeLength.

◆ tilt()

Vector3d tilt ( const Vector3d pos,
const Vector3d newZ 
)
inline

◆ Tokenize()

void Tokenize ( const std::string &  str,
std::vector< std::string > &  tokens,
const std::string &  delimiters = " " 
)

Global function which tokenizes the string at str according to the delimeters at delimeters and stores the tokens in the vector at tokens.

◆ UnitVector()

Vector3d UnitVector ( const Vector3d v)
inline

Variable Documentation

◆ InvalidOctreeIndex

const OctreeIndex InvalidOctreeIndex = std::numeric_limits<OctreeIndex>::max()