SDK/MLReference/mlFieldContainer_8h_source.html

 /*************************************************************************************

 **

 ** Copyright 2007, MeVis Medical Solutions AG

 **

 ** The user may use this file in accordance with the license agreement provided with

 ** the Software or, alternatively, in accordance with the terms contained in a

 ** written agreement between the user and MeVis Medical Solutions AG.

 **

 ** For further information use the contact form at https://www.mevislab.de/contact

 **

 **************************************************************************************/


 #ifndef ML_FIELD_CONTAINER_H

 #define ML_FIELD_CONTAINER_H


 // ML-includes

 #include "mlInitSystemML.h"

 #include "mlLinearAlgebra.h"

 #include "mlImageVector.h"

 #include "mlSubImageBox.h"


 #include "mlBase.h"

 #include "mlFieldSensor.h"

 #include "mlFields.h"

 #include "mlListFields.h"


 class SoNode;


 ML_START_NAMESPACE


 class InputConnector;

 class OutputConnector;

 class SubImageBoxd;


 //-------------------------------------------------------------------------

 //-------------------------------------------------------------------------

 class MLEXPORT FieldContainer : public Base {


   ML_DISALLOW_COPY_AND_ASSIGN(FieldContainer)


 public:

   FieldContainer();


   ~FieldContainer() override;


   std::string whoAmI(bool withInstanceName = true) const;


   Field* addField(const char* name, const char* type, const char* value);


   Field* addField(Field* field);


   BoolField* addBool(const char* name);

   BoolField* addBool(const char* name, bool value);


   IntField* addInt(const char*  name);

   IntField* addInt(const char*  name, MLint value);


   EnumField* addEnum(const char* name, const char* const * enumerationItemNames, MLint numEnumerationItems);


   EnumField* addEnum(const char* name, const std::vector<std::string> &enumerationItemNames);


   template<typename EnumType>

   TypedEnumField<EnumType>* addEnum(const char* name, const EnumValues<EnumType>& values, EnumType initialValue) {

     TypedEnumField<EnumType>* field = new TypedEnumField<EnumType>(name, values, initialValue);

     addField(field);

     return field;

   }


   FloatField* addFloat(const char* name);

   FloatField* addFloat(const char* name, float value);


   ProgressField* addProgress(const char* name);

   ProgressField* addProgress(const char* name, float value);


   DoubleField* addDouble(const char* name);

   DoubleField* addDouble(const char* name, double value);


   StringField* addString(const char* name);

   StringField* addString(const char* name, const std::string& value);


   NotifyField* addNotify(const char* name);

   TriggerField* addTrigger(const char* name);


   BaseField* addBase(const char* name);

   BaseField* addBase(const char* name, Base* value);

   BaseField* addBase(const char* name, const RefCountedBasePtr& value);

   template <typename T>

   BaseField* addBaseWithAllowedType(const char* name, T* value = nullptr)

   {

     BaseField* f = addBase(name);

     f->setBaseValueAndAddAllowedType(value);

     return f;

   }

   template <typename T>

   BaseField* addBaseWithAllowedType(const char* name, const ::boost::intrusive_ptr<T>& value)

   {

     return addBaseWithAllowedType(name, value.get());

   }


   template <typename T>

   TypedBaseField<T>* addTypedBase(const char* name)

   {

     TypedBaseField<T>* field = nullptr;


     field = new TypedBaseField<T>(name);

     addField(field);

     return field;

   }

   template <typename T>

   TypedBaseField<T>* addTypedBase(const char* name, T* value)

   {

     TypedBaseField<T>* field = addTypedBase<T>(name);

     field->setValue(value);

     return field;

   }

   template <typename T>

   TypedBaseField<T>* addTypedBase(const char* name, const ::boost::intrusive_ptr<T>& value)

   {

     TypedBaseField<T>* field = addTypedBase<T>(name);

     field->setValue(value);

     return field;

   }


   SoNodeField* addSoNode(const char* name);

   SoNodeField* addSoNode(const char* name, SoNode* value);


   PointerField* addPointer(const char* name);


   Vector2Field* addVector2(const char* name);

   Vector2Field* addVector2(const char* name, const Vector2& value);

   Vector2Field* addVector2(const char* name, double x, double y);


   Vector3Field* addVector3(const char* name);

   Vector3Field* addVector3(const char* name, const Vector3& value);

   Vector3Field* addVector3(const char* name, double x, double y, double z);


   Vector4Field* addVector4(const char* name);

   Vector4Field* addVector4(const char* name, const Vector4& value);

   Vector4Field* addVector4(const char* name, double x, double y, double z, double w);


   Vector5Field* addVector5(const char* name);

   Vector5Field* addVector5(const char* name, const Vector5& value);


   Vector6Field* addVector6(const char* name);

   Vector6Field* addVector6(const char* name, const Vector6& value);


   Vector10Field* addVector10(const char* name);

   Vector10Field* addVector10(const char* name, const Vector10& value);


   ImageVectorField* addImageVector(const char* name);

   ImageVectorField* addImageVector(const char* name, const ImageVector& value);

   ImageVectorField* addImageVector(const char* name, MLint x, MLint y, MLint z, MLint c, MLint t, MLint u);


   SubImageBoxField* addSubImageBox(const char* name);

   SubImageBoxField* addSubImageBox(const char* name, const SubImageBox& value);


   SubImageBoxdField* addSubImageBoxd(const char* name);

   SubImageBoxdField* addSubImageBoxd(const char* name, const SubImageBoxd& value);


   ColorField* addColor(const char* name);

   ColorField* addColor(const char* name, float r, float g, float b);

   ColorField* addColor(const char* name, const Vector3& value);


   PlaneField* addPlane(const char* name);

   PlaneField* addPlane(const char* name, double f0, double f1, double f2, double f3);

   PlaneField* addPlane(const char* name, const Plane& value);


   RotationField* addRotation(const char* name);

   RotationField* addRotation(const char* name, const Rotation& value);


   Matrix2Field*  addMatrix2(const char* name);

   Matrix2Field*  addMatrix2(const char* name, const Matrix2& value);


   Matrix3Field*  addMatrix3(const char* name);

   Matrix3Field*  addMatrix3(const char* name, const Matrix3& value);


   Matrix4Field*  addMatrix4(const char* name);

   Matrix4Field*  addMatrix4(const char* name, const Matrix4& value);


   Matrix5Field*  addMatrix5(const char* name);

   Matrix5Field*  addMatrix5(const char* name, const Matrix5& value);


   Matrix6Field*  addMatrix6(const char* name);

   Matrix6Field*  addMatrix6(const char* name, const Matrix6& value);


   MatrixField* addMatrix(const char* name);

   MatrixField* addMatrix(const char* name, const Matrix4& value);


   MLDataTypeField* addMLDataType(const char* name);

   MLDataTypeField* addMLDataType(const char* name, MLDataType value);


   UniversalTypeField* addUniversalType(const char* name);


   IntListField* addIntList(const char* name);

   IntListField* addIntList(const char* name, const std::vector<MLint>& value);


   DoubleListField* addDoubleList(const char* name);

   DoubleListField* addDoubleList(const char* name, const std::vector<double>& value);


   Vector2ListField* addVector2List(const char* name);

   Vector2ListField* addVector2List(const char* name, const std::vector<Vector2>& value);


   Vector3ListField* addVector3List(const char* name);

   Vector3ListField* addVector3List(const char* name, const std::vector<Vector3>& value);


   Vector4ListField* addVector4List(const char* name);

   Vector4ListField* addVector4List(const char* name, const std::vector<Vector4>& value);


   size_t getNumFields() const;


   bool hasField(const std::string& name) const;


   Field* getField(const std::string& name) const ;


   Field* getField(MLint index) const ;


   MLint getFieldIndex(Field* field) const;


   void setFieldStringValue(const std::string& name, const std::string& value);


   std::string getFieldStringValue(const std::string& name) const;


   virtual void activateAttachments()  { enableNotifications(true); }


   virtual void deactivateAttachments(){ enableNotifications(false); }


 private:

   bool removeField(Field* field);


   void enableNotifications(bool flag);


 protected:

   // Permit access from field to call handleNotificationInternal

   friend class Field;


   virtual void handleNotificationInternal(Field* /*field*/, FieldSensor::Strength /*strength*/) {};


 private:

   std::vector <Field*>                _fields;


   ML_ABSTRACT_CLASS_HEADER(FieldContainer)

 };


 ML_END_NAMESPACE


 //-----------------------------------------------------------------------------------

 //   Stream output for std::ostream

 //-----------------------------------------------------------------------------------

 namespace std

 {


   MLEXPORT std::ostream& operator<<(std::ostream& s, const ML_NAMESPACE::FieldContainer &fc);


 }


 #endif //of __mlFieldContainer_H


ml::BaseField
Field to encapsulate a pointer to an ML base object.
Definition: mlFields.h:729

ml::BaseField::setBaseValueAndAddAllowedType
void setBaseValueAndAddAllowedType(T *value)
Convenience routine for setting the base value and its type at the same time.
Definition: mlFields.h:780

ml::Base
Class representing general ML objects that support import/export via strings (setPersistentState() an...
Definition: mlBase.h:59

ml::BoolField
Field to encapsulate a boolean value.
Definition: mlFields.h:56

ml::ColorField
Field to encapsulate a vector of three float values representing an (RGB) color with all properties o...
Definition: mlFields.h:1332

ml::DoubleField
Field to encapsulate a double value.
Definition: mlFields.h:494

ml::DoubleListField
Definition: mlListFields.h:52

ml::EnumField
Field to encapsulate an enumerated value.
Definition: mlFields.h:173

ml::EnumValues
Helper class that stores a list of typed enum values and their string names.
Definition: mlFields.h:293

ml::FieldContainer
Defines the class FieldContainer to encapsulate a vector of fields (see class Field).
Definition: mlFieldContainer.h:54

ml::FieldContainer::addPlane
PlaneField * addPlane(const char *name, const Plane &value)
Creates a PlaneField with name and adds it to the container.

ml::FieldContainer::addMatrix5
Matrix5Field * addMatrix5(const char *name, const Matrix5 &value)
Creates a Matrix5Field with name and adds it to the container.

ml::FieldContainer::addVector2
Vector2Field * addVector2(const char *name, const Vector2 &value)
Creates a Vector2Field with name and adds it to the container.

ml::FieldContainer::addMatrix6
Matrix6Field * addMatrix6(const char *name)
Creates a Matrix6Field with name and adds it to the container.

ml::FieldContainer::addProgress
ProgressField * addProgress(const char *name)
Creates a float ProgressField with name and adds it to the container. Default value is 0....

ml::FieldContainer::getNumFields
size_t getNumFields() const
Returns the number of added fields.

ml::FieldContainer::handleNotificationInternal
virtual void handleNotificationInternal(Field *, FieldSensor::Strength)
Called when field has changed.
Definition: mlFieldContainer.h:417

ml::FieldContainer::addVector4
Vector4Field * addVector4(const char *name, const Vector4 &value)
Creates a Vector4Field with name and adds it to the container.

ml::FieldContainer::addProgress
ProgressField * addProgress(const char *name, float value)
Creates a float ProgressField with name and adds it to the container.

ml::FieldContainer::deactivateAttachments
virtual void deactivateAttachments()
Disables notification handling, i.e., all fields of this module will not send notifications to attach...
Definition: mlFieldContainer.h:398

ml::FieldContainer::addTrigger
TriggerField * addTrigger(const char *name)
Creates a TriggerField field with name and adds it to the container.

ml::FieldContainer::addSubImageBox
SubImageBoxField * addSubImageBox(const char *name, const SubImageBox &value)
Creates a SubImageBoxField with name and adds it to the container.

ml::FieldContainer::addVector4
Vector4Field * addVector4(const char *name)
Creates a Vector4Field with name and adds it to the container.

ml::FieldContainer::addMLDataType
MLDataTypeField * addMLDataType(const char *name)
Creates a MTDataTypeField with name and adds it to the container.

ml::FieldContainer::addIntList
IntListField * addIntList(const char *name, const std::vector< MLint > &value)
Creates an IntListField field with name and given list value and adds it to the container.

ml::FieldContainer::addRotation
RotationField * addRotation(const char *name, const Rotation &value)
Creates a RotationField with name and adds it to the container.

ml::FieldContainer::addBaseWithAllowedType
BaseField * addBaseWithAllowedType(const char *name, T *value=nullptr)
As above, but also sets the allowed type of the field.
Definition: mlFieldContainer.h:168

ml::FieldContainer::addVector5
Vector5Field * addVector5(const char *name, const Vector5 &value)
Creates a Vector5Field with name and adds it to the container.

ml::FieldContainer::addInt
IntField * addInt(const char *name, MLint value)
Creates an IntField with name and adds it to the container.

ml::FieldContainer::setFieldStringValue
void setFieldStringValue(const std::string &name, const std::string &value)
Sets the value of the field with name if it exists.

ml::FieldContainer::addEnum
EnumField * addEnum(const char *name, const std::vector< std::string > &enumerationItemNames)
Creates an EnumField field with name and adds it to the container.

ml::FieldContainer::addEnum
EnumField * addEnum(const char *name, const char *const *enumerationItemNames, MLint numEnumerationItems)
Creates an EnumField field with name and adds it to the container.

ml::FieldContainer::addMatrix
MatrixField * addMatrix(const char *name)
Creates a MatrixField with name and adds it to the container.

ml::FieldContainer::addNotify
NotifyField * addNotify(const char *name)
Creates a NotifyField field with name and adds it to the container.

ml::FieldContainer::addBase
BaseField * addBase(const char *name, Base *value)
Creates a Base field with name and adds it to the container.

ml::FieldContainer::addDouble
DoubleField * addDouble(const char *name)
Creates a DoubleField with name and adds it to the container. Default value is 0.

ml::FieldContainer::addBool
BoolField * addBool(const char *name, bool value)
Creates a BoolField with name and adds it to the container.

ml::FieldContainer::addVector3
Vector3Field * addVector3(const char *name, double x, double y, double z)
Creates a Vector3Field with name and adds it to the container.

ml::FieldContainer::addFloat
FloatField * addFloat(const char *name, float value)
Creates a FloatField with name and adds it to the container.

ml::FieldContainer::hasField
bool hasField(const std::string &name) const
Returns true if the field with name name exists; otherwise, false is returned.

ml::FieldContainer::addMatrix3
Matrix3Field * addMatrix3(const char *name)
Creates a Matrix3Field with name and adds it to the container.

ml::FieldContainer::getField
Field * getField(const std::string &name) const
Returns the pointer to the field with name name.

ml::FieldContainer::addDouble
DoubleField * addDouble(const char *name, double value)
Creates a DoubleField with name and adds it to the container.

ml::FieldContainer::addTypedBase
TypedBaseField< T > * addTypedBase(const char *name, T *value)
Creates a TypedBaseField with name and adds it to the container.
Definition: mlFieldContainer.h:193

ml::FieldContainer::addInt
IntField * addInt(const char *name)
Creates an IntField with name and adds it to the container. Default value is 0.

ml::FieldContainer::addMatrix6
Matrix6Field * addMatrix6(const char *name, const Matrix6 &value)
Creates a Matrix6Field with name and adds it to the container.

ml::FieldContainer::addField
Field * addField(const char *name, const char *type, const char *value)
Adds a new field with name name, type type, and value value (encoded as string) to the container.

ml::FieldContainer::addSubImageBoxd
SubImageBoxdField * addSubImageBoxd(const char *name)
Creates a SubImageBoxd field with name and adds it to the container.

ml::FieldContainer::addVector5
Vector5Field * addVector5(const char *name)
Creates a Vector5Field with name and adds it to the container.

ml::FieldContainer::addMLDataType
MLDataTypeField * addMLDataType(const char *name, MLDataType value)
Creates a MTDataTypeField with name and adds it to the container.

ml::FieldContainer::addMatrix
MatrixField * addMatrix(const char *name, const Matrix4 &value)
Creates a MatrixField with name and adds it to the container.

ml::FieldContainer::addVector4List
Vector4ListField * addVector4List(const char *name, const std::vector< Vector4 > &value)
Creates an Vector4ListField field with name and given list value and adds it to the container.

ml::FieldContainer::addImageVector
ImageVectorField * addImageVector(const char *name, const ImageVector &value)
Creates a ImageVectorField with name and adds it to the container.

ml::FieldContainer::addVector2List
Vector2ListField * addVector2List(const char *name)
Creates an Vector2ListField field with name and empty list value and adds it to the container.

ml::FieldContainer::addMatrix2
Matrix2Field * addMatrix2(const char *name)
Creates a Matrix2Field with name and adds it to the container.

ml::FieldContainer::addString
StringField * addString(const char *name)
Creates a StringField with name and adds it to the container. Default value is empty string.

ml::FieldContainer::addImageVector
ImageVectorField * addImageVector(const char *name)
Creates a ImageVectorField with name and adds it to the container.

ml::FieldContainer::addBase
BaseField * addBase(const char *name)
Creates a Base field with name and adds it to the container. Default value is NULL.

ml::FieldContainer::addVector10
Vector10Field * addVector10(const char *name, const Vector10 &value)
Creates a Vector10Field with name and adds it to the container.

ml::FieldContainer::addVector3
Vector3Field * addVector3(const char *name, const Vector3 &value)
Creates a Vector3Field with name and adds it to the container.

ml::FieldContainer::addColor
ColorField * addColor(const char *name, float r, float g, float b)
Creates a ColorField with name and adds it to the container.

ml::FieldContainer::addMatrix5
Matrix5Field * addMatrix5(const char *name)
Creates a Matrix5Field with name and adds it to the container.

ml::FieldContainer::addVector2
Vector2Field * addVector2(const char *name, double x, double y)
Creates a Vector2Field with name and adds it to the container.

ml::FieldContainer::addTypedBase
TypedBaseField< T > * addTypedBase(const char *name)
Creates a TypedBaseField with name and adds it to the container. Default value is NULL.
Definition: mlFieldContainer.h:183

ml::FieldContainer::addSoNode
SoNodeField * addSoNode(const char *name)
Creates a SoNodeField with name and adds it to the container. Default value is NULL.

ml::FieldContainer::addBool
BoolField * addBool(const char *name)
Creates a BoolField with name and adds it to the container. Default value is false.

ml::FieldContainer::addColor
ColorField * addColor(const char *name)
Creates a ColorField with name and adds it to the container.

ml::FieldContainer::addMatrix3
Matrix3Field * addMatrix3(const char *name, const Matrix3 &value)
Creates a Matrix3Field with name and adds it to the container.

ml::FieldContainer::addColor
ColorField * addColor(const char *name, const Vector3 &value)
Creates a ColorField with name and adds it to the container.

ml::FieldContainer::addEnum
TypedEnumField< EnumType > * addEnum(const char *name, const EnumValues< EnumType > &values, EnumType initialValue)
Creates a TypedEnumField field with name and adds it to the container.
Definition: mlFieldContainer.h:128

ml::FieldContainer::addSubImageBoxd
SubImageBoxdField * addSubImageBoxd(const char *name, const SubImageBoxd &value)
Creates a SubImageBoxd field with name and adds it to the container.

ml::FieldContainer::getFieldIndex
MLint getFieldIndex(Field *field) const
Returns index of field if it exists. If not, -1 is returned.

ml::FieldContainer::addVector3
Vector3Field * addVector3(const char *name)
Creates a Vector3Field with name and adds it to the container.

ml::FieldContainer::addBase
BaseField * addBase(const char *name, const RefCountedBasePtr &value)
Creates a Base field with name and adds it to the container. Sets the value from intrusive pointer.

ml::FieldContainer::addVector10
Vector10Field * addVector10(const char *name)
Creates a Vector10Field with name and adds it to the container.

ml::FieldContainer::FieldContainer
FieldContainer()
Constructor.

ml::FieldContainer::addRotation
RotationField * addRotation(const char *name)
Creates a RotationField with name and adds it to the container.

ml::FieldContainer::addTypedBase
TypedBaseField< T > * addTypedBase(const char *name, const ::boost::intrusive_ptr< T > &value)
Creates a TypedBaseField with name and adds it to the container. Sets the value from intrusive pointe...
Definition: mlFieldContainer.h:201

ml::FieldContainer::addSubImageBox
SubImageBoxField * addSubImageBox(const char *name)
Creates a SubImageBoxField with name and adds it to the container.

ml::FieldContainer::addFloat
FloatField * addFloat(const char *name)
Creates a FloatField with name and adds it to the container. Default value is 0.f.

ml::FieldContainer::addDoubleList
DoubleListField * addDoubleList(const char *name)
Creates an DoubleListField field with name and empty list value and adds it to the container.

ml::FieldContainer::addVector6
Vector6Field * addVector6(const char *name, const Vector6 &value)
Creates a Vector6Field with name and adds it to the container.

ml::FieldContainer::getField
Field * getField(MLint index) const
Returns pointer of field at index if it exists. If not, -1 is returned.

ml::FieldContainer::addVector2
Vector2Field * addVector2(const char *name)
Creates a Vector2Field with name and adds it to the container.

ml::FieldContainer::activateAttachments
virtual void activateAttachments()
Reactivates notification handling, i.e., all fields of this module will send notifications again to a...
Definition: mlFieldContainer.h:387

ml::FieldContainer::whoAmI
std::string whoAmI(bool withInstanceName=true) const
Returns the type and the instance name of format 'ClassTypeName(instanceName)' if the instance name i...

ml::FieldContainer::addSoNode
SoNodeField * addSoNode(const char *name, SoNode *value)
Creates a SoNodeField with name and adds it to the container.

ml::FieldContainer::addVector6
Vector6Field * addVector6(const char *name)
Creates a Vector6Field with name and adds it to the container.

ml::FieldContainer::addVector4
Vector4Field * addVector4(const char *name, double x, double y, double z, double w)
Creates a Vector4Field with name and adds it to the container.

ml::FieldContainer::addPlane
PlaneField * addPlane(const char *name, double f0, double f1, double f2, double f3)
Creates a PlaneField with name and adds it to the container.

ml::FieldContainer::addIntList
IntListField * addIntList(const char *name)
Creates an IntListField field with name and empty list value and adds it to the container.

ml::FieldContainer::addBaseWithAllowedType
BaseField * addBaseWithAllowedType(const char *name, const ::boost::intrusive_ptr< T > &value)
As above, but also sets the allowed type of the field.
Definition: mlFieldContainer.h:176

ml::FieldContainer::addVector3List
Vector3ListField * addVector3List(const char *name, const std::vector< Vector3 > &value)
Creates an Vector3ListField field with name and given list value and adds it to the container.

ml::FieldContainer::addMatrix2
Matrix2Field * addMatrix2(const char *name, const Matrix2 &value)
Creates a Matrix2Field with name and adds it to the container.

ml::FieldContainer::addUniversalType
UniversalTypeField * addUniversalType(const char *name)
Creates an UniversalTypeField field with name and adds it to the container.

ml::FieldContainer::addString
StringField * addString(const char *name, const std::string &value)
Creates a StringField with name and adds it to the container.

ml::FieldContainer::addImageVector
ImageVectorField * addImageVector(const char *name, MLint x, MLint y, MLint z, MLint c, MLint t, MLint u)
Creates a ImageVectorField with name and adds it to the container.

ml::FieldContainer::addDoubleList
DoubleListField * addDoubleList(const char *name, const std::vector< double > &value)
Creates an DoubleListField field with name and given list value and adds it to the container.

ml::FieldContainer::addPlane
PlaneField * addPlane(const char *name)
Creates a PlaneField with name and adds it to the container.

ml::FieldContainer::addVector2List
Vector2ListField * addVector2List(const char *name, const std::vector< Vector2 > &value)
Creates an Vector2ListField field with name and given list value and adds it to the container.

ml::FieldContainer::getFieldStringValue
std::string getFieldStringValue(const std::string &name) const
Returns the string value of the field with name if it is found.

ml::FieldContainer::addMatrix4
Matrix4Field * addMatrix4(const char *name)
Creates a Matrix4Field with name and adds it to the container.

ml::FieldContainer::~FieldContainer
~FieldContainer() override
Destructor: Deletes all added fields.

ml::FieldContainer::addVector3List
Vector3ListField * addVector3List(const char *name)
Creates an Vector3ListField field with name and empty list value and adds it to the container.

ml::FieldContainer::addField
Field * addField(Field *field)
Adds a field, the ownership of the field is passed to the FieldContainer.

ml::FieldContainer::addPointer
PointerField * addPointer(const char *name)
Creates a PointerField with name and adds it to the container.

ml::FieldContainer::addMatrix4
Matrix4Field * addMatrix4(const char *name, const Matrix4 &value)
Creates a Matrix4Field with name and adds it to the container.

ml::FieldContainer::addVector4List
Vector4ListField * addVector4List(const char *name)
Creates an Vector4ListField field with name and empty list value and adds it to the container.

ml::FieldSensor::Strength
Strength
Enumeration type describing the strength of notifications.
Definition: mlFieldSensor.h:44

ml::Field
Base class for all fields used in the ML.
Definition: mlField.h:73

ml::FloatField
Field to encapsulate a float value.
Definition: mlFields.h:389

ml::ImageVectorField
Field to encapsulate an ML vector ImageVector with six integer components.
Definition: mlFields.h:1752

ml::IntField
Field to encapsulate an integer value.
Definition: mlFields.h:117

ml::IntListField
Definition: mlListFields.h:31

ml::MLDataTypeField
Field to encapsulate an MLDataType value.
Definition: mlFields.h:1707

ml::Matrix2Field
Field encapsulating a 2x2 matrix.
Definition: mlFields.h:1378

ml::Matrix3Field
Field encapsulating a 3x3 matrix.
Definition: mlFields.h:1439

ml::Matrix4Field
Field to encapsulate a 4x4 matrix.
Definition: mlFields.h:1567

ml::Matrix5Field
Field encapsulating a 5x5 matrix.
Definition: mlFields.h:1582

ml::Matrix6Field
Field encapsulating a 6x6 matrix.
Definition: mlFields.h:1644

ml::MatrixField
Field to encapsulate a 4x4 matrix, same as Matrix4Field for backward compatibility.
Definition: mlFields.h:1501

ml::NotifyField
Field without value for notifications.
Definition: mlFields.h:598

ml::PlaneField
Field to encapsulate a vector of four double values representing a plane with all properties of Vecto...
Definition: mlFields.h:2036

ml::Plane
Class defining a plane in 3D.
Definition: mlPlane.h:30

ml::PointerField
Field to encapsulate a void pointer to arbitrary data.
Definition: mlFields.h:917

ml::ProgressField
Field to encapsulate an increasing float value from range [0,1].
Definition: mlFields.h:451

ml::RotationField
Field to encapsulate a vector of four double values representing a rotation with all properties of Ve...
Definition: mlFields.h:2007

ml::Rotation
Class to handle Rotations (internally, the rotation is stored as a unit quaternion)
Definition: mlRotation.h:38

ml::SoNodeField
Field to encapsulate a pointer to an SoNode instance of OpenInventor.
Definition: mlFields.h:865

ml::StringField
Field to encapsulate a string value.
Definition: mlFields.h:553

ml::SubImageBoxField
Field to encapsulate an ML integer SubimgBox.
Definition: mlFields.h:1806

ml::SubImageBoxdField
Field to encapsulate an ML double SubimgBox.
Definition: mlFields.h:1860

ml::SubImageBoxd
SubImageBoxd - SubImageBox with coordinates of float data type.
Definition: mlSubImageBoxd.h:33

ml::TImageVector< MLint >

ml::TSubImageBox< MLint >

ml::Tmat2< MLdouble >

ml::Tmat3< MLdouble >

ml::Tmat4< MLdouble >

ml::Tmat5< MLdouble >

ml::Tmat6< MLdouble >

ml::Tvec10< MLdouble >

ml::Tvec2< MLdouble >

ml::Tvec3< MLdouble >

ml::Tvec4< MLdouble >

ml::Tvec5< MLdouble >

ml::Tvec6< MLdouble >

ml::TypedBaseField
Templated version of BaseField that only stores the template type as pointer.
Definition: mlFields.h:835

ml::TypedBaseField::setValue
void setValue(T *basePointerValue)
Sets the value of the field to basePointerValue.
Definition: mlFields.h:841

ml::TypedEnumField
TypedEnumField is used to encapsulate a C++ enum value and work with a real enum value instead of int...
Definition: mlFields.h:358

ml::UniversalTypeField
Field to encapsulate any of the registered ML types.
Definition: mlFields.h:1915

ml::Vector10Field
Field to encapsulate a vector of ten double values.
Definition: mlFields.h:1267

ml::Vector2Field
Field to encapsulate a vector of two double values.
Definition: mlFields.h:960

ml::Vector2ListField
Definition: mlListFields.h:73

ml::Vector3Field
Field to encapsulate a vector of three double values.
Definition: mlFields.h:1019

ml::Vector3ListField
Definition: mlListFields.h:94

ml::Vector4Field
Field to encapsulate a vector of four double values.
Definition: mlFields.h:1081

ml::Vector4ListField
Definition: mlListFields.h:115

ml::Vector5Field
Field to encapsulate a vector of five double values.
Definition: mlFields.h:1142

ml::Vector6Field
Field to encapsulate a vector of six double values.
Definition: mlFields.h:1205

ML_DISALLOW_COPY_AND_ASSIGN
#define ML_DISALLOW_COPY_AND_ASSIGN(className)
Defines basic macros.
Definition: mlMacros.h:23

ML_ABSTRACT_CLASS_HEADER
#define ML_ABSTRACT_CLASS_HEADER(className)
Similar to ML_ABSTRACT_CLASS_HEADER_EXPORTED with a non-existing export symbol.
Definition: mlRuntimeSubClass.h:202

MLDataType
MLint32 MLDataType
MLDataType.
Definition: mlTypeDefs.h:596

mlBase.h

mlFieldSensor.h

std::operator<<
MLEXPORT std::ostream & operator<<(std::ostream &s, const ml::Field &v)
Overloads the operator '<<' for stream output of Field objects.

mlFields.h

mlImageVector.h

mlInitSystemML.h

MLEXPORT
#define MLEXPORT
To export symbols from a DLL/shared object, we need to mark them with the MLEXPORT symbol.
Definition: mlInitSystemML.h:38

mlLinearAlgebra.h

mlListFields.h

mlSubImageBox.h

MLint
MLint64 MLint
A signed ML integer type with at least 64 bits used for index calculations on very large images even ...
Definition: mlTypeDefs.h:490