| IGLib 1.4 The IGLib base library for development of numerical, technical and business applications.

- Main Page
- Namespaces
- Classes
- Files
- Directories

- Class List
- Class Index
- Class Hierarchy
- Class Members

Classes | Public Member Functions | Static Public Member Functions | Protected Attributes | Properties | Private Attributes

# IG::Num::Field< TElement > Class Template Reference

A generic field of values of any type. Values must be allocated at once. More...

Inheritance diagram for IG::Num::Field< TElement >:
[legend]

List of all members.

## Classes
class | ExampleClassScalarField
| Example of a field class. More...
## Public Member Functions
| Field ()
| Constructs a new empty field (no elements contained) with no name and no description.
| Field (int numElements)
| Creates a new field with the specified number of elements.
| Field (int numElements, string fieldName)
| Constructs a new field with the specified number of elements and name.
| Field (int numElements, string fieldName, string fieldDescription)
| Constructs a new field with the specified number of elements, name and description. Table of elements is allocated.
virtual void | SetLength (int newLength)
| Sets the length of the current field to the specified value.
TElement | GetValue (int index)
| Returns element of the field at the specified index.
void | SetValue (int index, TElement value)
| Sets the element at the specified index to the specified value.
## Static Public Member Functions
static void | UpdateBounds (Field< double > field, IBoundingBox bounds, int componentIndex)
| Updates the specified component of the specified bounds (object of type IBoundingBox) in such a way that all elements of the specified field will fit within the bounds. Call has no effect if the field is null. Bounding box object must be allocated and of the dimension greater that the specified coordinate index.
static void | UpdateBounds< TEl > (Field< TEl > field, IBoundingBox bounds)
| Updates the specified bounds (object of type IBoundingBox) in such a way that all non-null vectors on the specified field will fit within the bounds. Call has no effect if the field is null. Bounding box object must be allocated and of the same dimension as elements of the field.
static void | UpdateBounds (Field< vec3 > field, IBoundingBox bounds)
| Updates the specified bounds (object of type IBoundingBox) in such a way that all 3D vector elements of type vec3 of the specified field will fit within the bounds. Call has no effect if the field is null. Bounding box object must be allocated and of dimension 3.
static void | MapCoordinatesPlain (Field< vec3 > referenceField, Field< vec3 > targetField, IFunc3d fx, IFunc3d fy, IFunc3d fz)
| Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 3 scalar functions of 3 variables that map coordinates of the reference points to components of the mapped points. Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | MapCoordinates (Field< vec3 > referenceField, Field< vec3 > targetField, IFunc3d fx, IFunc3d fy, IFunc3d fz)
| Generates coordinates of a set of unstructured points (point cloud) from a reference set according to 3 scalar functions of 3 variables that map coordinates of the reference points to components of the mapped points. Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | MapCoordinates2dPlain (Field< vec3 > referenceField, Field< vec3 > targetField, IFunc2d fx, IFunc2d fy, IFunc2d fz)
| Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 3 scalar functions of 2 variables that map coordinates of the reference points to components of the mapped points. Mapping functions act only on the first two coordinates of each point. This function is usually used for mapping coordinates of 2D structures embedded in 3D space.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | MapCoordinates2d (Field< vec3 > referenceField, Field< vec3 > targetField, IFunc2d fx, IFunc2d fy, IFunc2d fz)
| Generates coordinates of a set of unstructured points (point cloud) from a reference set according to 3 scalar functions of 2 variables that map the first two coordinates of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 2D structures embedded in 3D space.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | MapCoordinates1dPlain (Field< vec3 > referenceField, Field< vec3 > targetField, IRealFunction fx, IRealFunction fy, IRealFunction fz)
| Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 3 functions of 1 variable that map the first coordinate of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 1D structures embedded in 3D space.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | MapCoordinates1d (Field< vec3 > referenceField, Field< vec3 > targetField, IRealFunction fx, IRealFunction fy, IRealFunction fz)
| Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 3 functions of 1 variable that map the first coordinate of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 1D structures embedded in 3D space.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | MapCoordinatesToScalarsPlain (Field< vec3 > referenceField, Field< double > targetScalarField, IFunc3d scalarMap)
| Generates scalar values for a 3D unstructured set fo points from the specified field of grid coordinates by a specified scalar function of 3 variables that maps coordinates to scalar values. Function can be used for any mapping of nodal vector values to nodal scalar values of an unstructured grid, not just for mapping of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | MapCoordinatesToScalars (Field< vec3 > referenceField, Field< double > targetScalarField, IFunc3d scalarMap)
| Generates scalar values for a 3D unstructured set fo points from the specified field of grid coordinates by a specified scalar function of 3 variables that maps coordinates to scalar values. Function can be used for any mapping of nodal vector values to nodal scalar values of an unstructured grid, not just for mapping of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinatesPlain (Field< vec3 > field, int dimx, int dimy, int dimz, double minxRef, double maxxRef, double minyRef, double maxyRef, double minzRef, double maxzRef)
| Generates coordinates of a 3D unstructured grid from a regular grid with grid directions parallel to coordinate axes and equidistantly arranged nodes in all directions. This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates (Field< vec3 > field, int dimx, int dimy, int dimz, double minxRef, double maxxRef, double minyRef, double maxyRef, double minzRef, double maxzRef)
| Generates coordinates of a 3D unstructured grid from a regular grid with grid directions parallel to coordinate axes and equidistantly arranged nodes in all directions. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinatesPlain (Field< vec3 > field, int dimx, int dimy, int dimz, double minxRef, double maxxRef, double minyRef, double maxyRef, double minzRef, double maxzRef, IFunc3d fx, IFunc3d fy, IFunc3d fz)
| Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates (Field< vec3 > field, int dimx, int dimy, int dimz, double minxRef, double maxxRef, double minyRef, double maxyRef, double minzRef, double maxzRef, IFunc3d fx, IFunc3d fy, IFunc3d fz)
| Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | UpdateBounds (Field< vec2 > field, IBoundingBox bounds)
| Updates the specified bounds (object of type IBoundingBox) in such a way that all 2D vector elements of type vec2 of the specified field will fit within the bounds. Call has no effect if the field is null. Bounding box object must be allocated and of dimension 3.
static void | MapCoordinatesPlain (Field< vec2 > referenceField, Field< vec2 > targetField, IFunc2d fx, IFunc2d fy)
| Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 2 scalar functions of 2 variables that map coordinates of the reference points to components of the mapped points. Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | MapCoordinates (Field< vec2 > referenceField, Field< vec2 > targetField, IFunc2d fx, IFunc2d fy)
| Generates coordinates of a set of unstructured points (point cloud) from a reference set according to 2 scalar functions of 2 variables that map coordinates of the reference points to components of the mapped points. Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | MapCoordinates1dPlain (Field< vec2 > referenceField, Field< vec2 > targetField, IRealFunction fx, IRealFunction fy)
| Generates coordinates of a set of unstructured 2D points (point cloud) from a reference set according to 2 functions of 1 variables that map the first coordinate of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 2D structures embedded in 3D.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | MapCoordinates1d (Field< vec2 > referenceField, Field< vec2 > targetField, IRealFunction fx, IRealFunction fy)
| Generates coordinates of a set of unstructured 2D points (point cloud) from a reference set according to 2 functions of 1 variables that map the first coordinate of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 2D structures embedded in 3D.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | MapCoordinatesToScalarsPlain (Field< vec2 > referenceField, Field< double > targetScalarField, IFunc2d scalarMap)
| Generates scalar values for a 2D unstructured set fo points from the specified field of grid coordinates by a specified scalar function of 2 variables that maps coordinates to scalar values. Function can be used for any mapping of nodal vector values to nodal scalar values of an unstructured set of nodes, not just for mapping of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | MapCoordinatesToScalars (Field< vec2 > referenceField, Field< double > targetScalarField, IFunc2d scalarMap)
| Generates scalar values for a 2D unstructured set fo points from the specified field of grid coordinates by a specified scalar function of 2 variables that maps coordinates to scalar values. Function can be used for any mapping of nodal vector values to nodal scalar values of an unstructured set of nodes, not just for mapping of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinatesPlain (Field< vec2 > field, int dimx, int dimy, double minxRef, double maxxRef, double minyRef, double maxyRef)
| Generates coordinates of a 3D unstructured grid from a regular grid with grid directions parallel to coordinate axes and equidistantly arranged nodes in all directions. This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates (Field< vec2 > field, int dimx, int dimy, double minxRef, double maxxRef, double minyRef, double maxyRef)
| Generates coordinates of a 3D unstructured grid from a regular grid with grid directions parallel to coordinate axes and equidistantly arranged nodes in all directions. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinatesPlain (Field< vec2 > field, int dimx, int dimy, double minxRef, double maxxRef, double minyRef, double maxyRef, IFunc2d fx, IFunc2d fy)
| Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates (Field< vec2 > field, int dimx, int dimy, double minxRef, double maxxRef, double minyRef, double maxyRef, IFunc2d fx, IFunc2d fy)
| Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinates2dPlain (Field< vec3 > field, int dimx, int dimy, double minxRef, double maxxRef, double minyRef, double maxyRef)
| Generates coordinates of a 2D unstructured grid embedded in 3D from a regular grid with grid directions parallel to the first two coordinate axes and equidistantly arranged nodes in all directions. This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates2d (Field< vec3 > field, int dimx, int dimy, double minxRef, double maxxRef, double minyRef, double maxyRef)
| Generates coordinates of a 2D unstructured grid embedded in 3D from a regular grid with grid directions parallel to the first two coordinate axes and equidistantly arranged nodes in all directions. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinates2dPlain (Field< vec3 > field, int dimx, int dimy, double minxRef, double maxxRef, double minyRef, double maxyRef, IFunc2d fx, IFunc2d fy, IFunc2d fz)
| Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates2d (Field< vec3 > field, int dimx, int dimy, double minxRef, double maxxRef, double minyRef, double maxyRef, IFunc2d fx, IFunc2d fy, IFunc2d fz)
| Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinates1dPlain (Field< vec3 > field, int dimx, double minxRef, double maxxRef)
| Generates coordinates of a 1D unstructured grid from a regular grid with grid direction parallel to X coordinate axes and equidistantly arranged nodes. This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates1d (Field< vec3 > field, int dimx, double minxRef, double maxxRef)
| Generates coordinates of a 1D unstructured grid from a regular grid with grid direction parallel to X coordinate axis and equidistantly arranged nodes. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinates1dPlain (Field< vec3 > field, int dimx, double minxRef, double maxxRef, IRealFunction fx, IRealFunction fy, IRealFunction fz)
| Generates coordinates of a 1D unstructured grid of a parametric curve according to functions specifying the x, y, and z coordinates in terms of three functions of 1 variable. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates1d (Field< vec3 > field, int dimx, double minxRef, double maxxRef, IRealFunction fx, IRealFunction fy, IRealFunction fz)
| Generates coordinates of a 1D unstructured grid of a parametric curve according to functions specifying the x, y, and z coordinates in terms of three functions of 1 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinates1dPlain (Field< vec2 > field, int dimx, double minxRef, double maxxRef)
| Generates coordinates of a 1D unstructured grid embedded in 2D space from a regular grid with grid direction parallel to X coordinate axes and equidistantly arranged nodes. This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates (Field< vec2 > field, int dimx, double minxRef, double maxxRef)
| Generates coordinates of a 1D unstructured grid embedded in 2D space from a regular grid with grid direction parallel to X coordinate axis and equidistantly arranged nodes. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | GenerateCoordinates1dPlain (Field< vec2 > field, int dimx, double minxRef, double maxxRef, IRealFunction fx, IRealFunction fy)
| Generates coordinates of a 1D unstructured grid embedded in 2D space of a parametric curve according to functions specifying the x, and y coordinates in terms of 2 functions of 1 variable. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.
static void | GenerateCoordinates1d (Field< vec2 > field, int dimx, double minxRef, double maxxRef, IRealFunction fx, IRealFunction fy)
| Generates coordinates of a 1D unstructured grid embedded in 2D space of a parametric curve according to functions specifying the x, and y coordinates in terms of 2 functions of 1 variable. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.
static void | Example ()
## Protected Attributes
TElement[] | _values
## Properties
string | Name`[get, set]`
| Name of the field.
string | Description`[get, set]`
| Description of the field.
virtual TElement[] | Values`[get, set]`
| Array of field values.
int | Length`[get, set]`
| Number of elements.
TElement | this [int index]`[get, set]`
| Access to elements through element index.
## Private Attributes
string | _name
string | _description
int | _length

## Detailed Description

### template<TElement>
class IG::Num::Field< TElement >

A generic field of values of any type. Values must be allocated at once.

Template Parameters:

  TElement | Type of elements of the field.

$A Igor Jan08 Mar09;

## Member Function Documentation

template<TElement >

IG::Num::Field< TElement >::Field | ( |  | ) | `[inline]`

Constructs a new empty field (no elements contained) with no name and no description.

template<TElement >

IG::Num::Field< TElement >::Field | ( | int | numElements | ) | `[inline]`

Creates a new field with the specified number of elements.

Parameters:

  numElements | Number of elements of teh field.

template<TElement >

IG::Num::Field< TElement >::Field | ( | int | numElements,
|  | string | fieldName
| ) |  | `[inline]`

Constructs a new field with the specified number of elements and name.

Parameters:

  numElements | Number of elements.
  fieldName | Name of the field.

template<TElement >

IG::Num::Field< TElement >::Field | ( | int | numElements,
|  | string | fieldName,
|  | string | fieldDescription
| ) |  | `[inline]`

Constructs a new field with the specified number of elements, name and description. Table of elements is allocated.

Parameters:

  numElements | Number of elements.
  fieldName | Name of the field.
  fieldDescription | Field description.

template<TElement >

virtual void IG::Num::Field< TElement >::SetLength | ( | int | newLength | ) | `[inline, virtual]`

Sets the length of the current field to the specified value.

Parameters:

  newLength | New length (number of elements) of the field.

template<TElement >

TElement IG::Num::Field< TElement >::GetValue | ( | int | index | ) | `[inline]`

Returns element of the field at the specified index.

Parameters:

  index | Index for which field element is returned.

template<TElement >

void IG::Num::Field< TElement >::SetValue | ( | int | index,
|  | TElement | value
| ) |  | `[inline]`

Sets the element at the specified index to the specified value.

Parameters:

  index | Indec of the element to be set.
  value | Value that is assigned to the specified element.

template<TElement >

static void IG::Num::Field< TElement >::UpdateBounds | ( | Field< double > | field,
|  | IBoundingBox | bounds,
|  | int | componentIndex
| ) |  | `[inline, static]`

Updates the specified component of the specified bounds (object of type IBoundingBox) in such a way that all elements of the specified field will fit within the bounds. Call has no effect if the field is null. Bounding box object must be allocated and of the dimension greater that the specified coordinate index.

Parameters:

  field | Field according to whose elements the bounds are updated.
  bounds | Bounding box object that is updated in such a way that all elements of the field fit in it.
  componentIndex | Index of component of bounding box that is updated.

template<TElement >

static void IG::Num::Field< TElement >::UpdateBounds< TEl > | ( | Field< TEl > | field,
|  | IBoundingBox | bounds
| ) |  | `[inline, static]`

Updates the specified bounds (object of type IBoundingBox) in such a way that all non-null vectors on the specified field will fit within the bounds. Call has no effect if the field is null. Bounding box object must be allocated and of the same dimension as elements of the field.

Template Parameters:

  TElement | Type of elements of the field, must be IVector.

Parameters:

  field | Field according to whose elements the bounds are updated.
  bounds | Bounding box object that is updated in such a way that all elements of the field fit in it.

Type Constraints

  TEl | : | IVector |

template<TElement >

static void IG::Num::Field< TElement >::UpdateBounds | ( | Field< vec3 > | field,
|  | IBoundingBox | bounds
| ) |  | `[inline, static]`

Updates the specified bounds (object of type IBoundingBox) in such a way that all 3D vector elements of type vec3 of the specified field will fit within the bounds. Call has no effect if the field is null. Bounding box object must be allocated and of dimension 3.

Parameters:

  field | Field according to whose 3D vector elements the bounds are updated.
  bounds | Bounding box object that is updated in such a way that all elements of the field fit in it. Must be of dimension 3.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinatesPlain | ( | Field< vec3 > | referenceField,
|  | Field< vec3 > | targetField,
|  | IFunc3d | fx,
|  | IFunc3d | fy,
|  | IFunc3d | fz
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 3 scalar functions of 3 variables that map coordinates of the reference points to components of the mapped points. Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinates | ( | Field< vec3 > | referenceField,
|  | Field< vec3 > | targetField,
|  | IFunc3d | fx,
|  | IFunc3d | fy,
|  | IFunc3d | fz
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured points (point cloud) from a reference set according to 3 scalar functions of 3 variables that map coordinates of the reference points to components of the mapped points. Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinates2dPlain | ( | Field< vec3 > | referenceField,
|  | Field< vec3 > | targetField,
|  | IFunc2d | fx,
|  | IFunc2d | fy,
|  | IFunc2d | fz
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 3 scalar functions of 2 variables that map coordinates of the reference points to components of the mapped points. Mapping functions act only on the first two coordinates of each point. This function is usually used for mapping coordinates of 2D structures embedded in 3D space.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinates2d | ( | Field< vec3 > | referenceField,
|  | Field< vec3 > | targetField,
|  | IFunc2d | fx,
|  | IFunc2d | fy,
|  | IFunc2d | fz
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured points (point cloud) from a reference set according to 3 scalar functions of 2 variables that map the first two coordinates of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 2D structures embedded in 3D space.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinates1dPlain | ( | Field< vec3 > | referenceField,
|  | Field< vec3 > | targetField,
|  | IRealFunction | fx,
|  | IRealFunction | fy,
|  | IRealFunction | fz
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 3 functions of 1 variable that map the first coordinate of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 1D structures embedded in 3D space.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinates1d | ( | Field< vec3 > | referenceField,
|  | Field< vec3 > | targetField,
|  | IRealFunction | fx,
|  | IRealFunction | fy,
|  | IRealFunction | fz
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 3 functions of 1 variable that map the first coordinate of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 1D structures embedded in 3D space.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinatesToScalarsPlain | ( | Field< vec3 > | referenceField,
|  | Field< double > | targetScalarField,
|  | IFunc3d | scalarMap
| ) |  | `[inline, static]`

Generates scalar values for a 3D unstructured set fo points from the specified field of grid coordinates by a specified scalar function of 3 variables that maps coordinates to scalar values. Function can be used for any mapping of nodal vector values to nodal scalar values of an unstructured grid, not just for mapping of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  referenceField | Field containing coordinates that will be mapped to scalar values.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field in which the mapped scalars are stored.

Dimensions must be set and consistent with dimensions of the reference field, and array of values must be allocated before the function is called.

Parameters:

  scalarMap | Function that maps node coordinates of the reference grid to scalar values of the target grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinatesToScalars | ( | Field< vec3 > | referenceField,
|  | Field< double > | targetScalarField,
|  | IFunc3d | scalarMap
| ) |  | `[inline, static]`

Generates scalar values for a 3D unstructured set fo points from the specified field of grid coordinates by a specified scalar function of 3 variables that maps coordinates to scalar values. Function can be used for any mapping of nodal vector values to nodal scalar values of an unstructured grid, not just for mapping of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  referenceField | Field containing coordinates that will be mapped to scalar values.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field in which the mapped scalars are stored.

Dimensions must be set and consistent with dimensions of the reference field, and array of values must be allocated before the function is called.

Parameters:

  scalarMap | Function that maps node coordinates of the reference grid to scalar values of the target grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinatesPlain | ( | Field< vec3 > | field,
|  | int | dimx,
|  | int | dimy,
|  | int | dimz,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef,
|  | double | minzRef,
|  | double | maxzRef
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid from a regular grid with grid directions parallel to coordinate axes and equidistantly arranged nodes in all directions. This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Minimal value of x coordinate of the generated grid.
  maxxRef | Maximal value of x coordinate of the generated grid.
  minyRef | Minimal value of y coordinate of the generated grid.
  maxyRef | Maximal value of y coordinate of the generated grid.
  minzRef | Minimal value of z coordinate of the generated grid.
  maxzRef | Maximal value of z coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates | ( | Field< vec3 > | field,
|  | int | dimx,
|  | int | dimy,
|  | int | dimz,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef,
|  | double | minzRef,
|  | double | maxzRef
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid from a regular grid with grid directions parallel to coordinate axes and equidistantly arranged nodes in all directions. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Minimal value of x coordinate of the generated grid.
  maxxRef | Maximal value of x coordinate of the generated grid.
  minyRef | Minimal value of y coordinate of the generated grid.
  maxyRef | Maximal value of y coordinate of the generated grid.
  minzRef | Minimal value of z coordinate of the generated grid.
  maxzRef | Maximal value of z coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinatesPlain | ( | Field< vec3 > | field,
|  | int | dimx,
|  | int | dimy,
|  | int | dimz,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef,
|  | double | minzRef,
|  | double | maxzRef,
|  | IFunc3d | fx,
|  | IFunc3d | fy,
|  | IFunc3d | fz
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  minyRef | Lower bound for the second parameter in the reference coordinate system.
  maxyRef | Upper bound for the second parameter in the reference coordinate system.
  minzRef | Lower bound for the third parameter in the reference coordinate system.
  maxzRef | Upper bound for the third parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates | ( | Field< vec3 > | field,
|  | int | dimx,
|  | int | dimy,
|  | int | dimz,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef,
|  | double | minzRef,
|  | double | maxzRef,
|  | IFunc3d | fx,
|  | IFunc3d | fy,
|  | IFunc3d | fz
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  minyRef | Lower bound for the second parameter in the reference coordinate system.
  maxyRef | Upper bound for the second parameter in the reference coordinate system.
  minzRef | Lower bound for the third parameter in the reference coordinate system.
  maxzRef | Upper bound for the third parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::UpdateBounds | ( | Field< vec2 > | field,
|  | IBoundingBox | bounds
| ) |  | `[inline, static]`

Updates the specified bounds (object of type IBoundingBox) in such a way that all 2D vector elements of type vec2 of the specified field will fit within the bounds. Call has no effect if the field is null. Bounding box object must be allocated and of dimension 3.

Parameters:

  field | Field according to whose 2D vector elements the bounds are updated.
  bounds | Bounding box object that is updated in such a way that all elements of the field fit in it. Must be of dimension 2.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinatesPlain | ( | Field< vec2 > | referenceField,
|  | Field< vec2 > | targetField,
|  | IFunc2d | fx,
|  | IFunc2d | fy
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured 3D points (point cloud) from a reference set according to 2 scalar functions of 2 variables that map coordinates of the reference points to components of the mapped points. Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinates | ( | Field< vec2 > | referenceField,
|  | Field< vec2 > | targetField,
|  | IFunc2d | fx,
|  | IFunc2d | fy
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured points (point cloud) from a reference set according to 2 scalar functions of 2 variables that map coordinates of the reference points to components of the mapped points. Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinates1dPlain | ( | Field< vec2 > | referenceField,
|  | Field< vec2 > | targetField,
|  | IRealFunction | fx,
|  | IRealFunction | fy
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured 2D points (point cloud) from a reference set according to 2 functions of 1 variables that map the first coordinate of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 2D structures embedded in 3D.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinates1d | ( | Field< vec2 > | referenceField,
|  | Field< vec2 > | targetField,
|  | IRealFunction | fx,
|  | IRealFunction | fy
| ) |  | `[inline, static]`

Generates coordinates of a set of unstructured 2D points (point cloud) from a reference set according to 2 functions of 1 variables that map the first coordinate of the reference points to components of the mapped points. This function is usually used for mapping coordinates of 2D structures embedded in 3D.Target field can be the same as the reference field (in this case vectors of the reference field are overwritten one by one).Function can be used for transformation of any nodal vector values of a set of nodes, not just for transformation of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  referenceField | Field containing reference coordinates that will be mapped to actual coordinates.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field for which coordinates are generated.

Dimensions must be set and consistent with dimensions of the reference field, and array of vector values must be allocated before the function is called.

This parameter can be the same field as referenceField .

Parameters:

  fx | Function that maps node coordinates of the reference grid to the first node coordinates of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinatesToScalarsPlain | ( | Field< vec2 > | referenceField,
|  | Field< double > | targetScalarField,
|  | IFunc2d | scalarMap
| ) |  | `[inline, static]`

Generates scalar values for a 2D unstructured set fo points from the specified field of grid coordinates by a specified scalar function of 2 variables that maps coordinates to scalar values. Function can be used for any mapping of nodal vector values to nodal scalar values of an unstructured set of nodes, not just for mapping of coordinates.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  referenceField | Field containing coordinates that will be mapped to scalar values.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field in which the mapped scalars are stored.

Dimensions must be set and consistent with dimensions of the reference field, and array of values must be allocated before the function is called.

Parameters:

  scalarMap | Function that maps node coordinates of the reference grid to scalar values of the target grid.

template<TElement >

static void IG::Num::Field< TElement >::MapCoordinatesToScalars | ( | Field< vec2 > | referenceField,
|  | Field< double > | targetScalarField,
|  | IFunc2d | scalarMap
| ) |  | `[inline, static]`

Generates scalar values for a 2D unstructured set fo points from the specified field of grid coordinates by a specified scalar function of 2 variables that maps coordinates to scalar values. Function can be used for any mapping of nodal vector values to nodal scalar values of an unstructured set of nodes, not just for mapping of coordinates.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  referenceField | Field containing coordinates that will be mapped to scalar values.

Dimensions must be set and array of vector values (coordinates) must be allocated before the function is called.

Parameters:

  targetField | Field in which the mapped scalars are stored.

Dimensions must be set and consistent with dimensions of the reference field, and array of values must be allocated before the function is called.

Parameters:

  scalarMap | Function that maps node coordinates of the reference grid to scalar values of the target grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinatesPlain | ( | Field< vec2 > | field,
|  | int | dimx,
|  | int | dimy,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid from a regular grid with grid directions parallel to coordinate axes and equidistantly arranged nodes in all directions. This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Minimal value of x coordinate of the generated grid.
  maxxRef | Maximal value of x coordinate of the generated grid.
  minyRef | Minimal value of y coordinate of the generated grid.
  maxyRef | Maximal value of y coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates | ( | Field< vec2 > | field,
|  | int | dimx,
|  | int | dimy,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid from a regular grid with grid directions parallel to coordinate axes and equidistantly arranged nodes in all directions. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Minimal value of x coordinate of the generated grid.
  maxxRef | Maximal value of x coordinate of the generated grid.
  minyRef | Minimal value of y coordinate of the generated grid.
  maxyRef | Maximal value of y coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinatesPlain | ( | Field< vec2 > | field,
|  | int | dimx,
|  | int | dimy,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef,
|  | IFunc2d | fx,
|  | IFunc2d | fy
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  minyRef | Lower bound for the second parameter in the reference coordinate system.
  maxyRef | Upper bound for the second parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates | ( | Field< vec2 > | field,
|  | int | dimx,
|  | int | dimy,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef,
|  | IFunc2d | fx,
|  | IFunc2d | fy
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  minyRef | Lower bound for the second parameter in the reference coordinate system.
  maxyRef | Upper bound for the second parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates2dPlain | ( | Field< vec3 > | field,
|  | int | dimx,
|  | int | dimy,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef
| ) |  | `[inline, static]`

Generates coordinates of a 2D unstructured grid embedded in 3D from a regular grid with grid directions parallel to the first two coordinate axes and equidistantly arranged nodes in all directions. This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Minimal value of x coordinate of the generated grid.
  maxxRef | Maximal value of x coordinate of the generated grid.
  minyRef | Minimal value of y coordinate of the generated grid.
  maxyRef | Maximal value of y coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates2d | ( | Field< vec3 > | field,
|  | int | dimx,
|  | int | dimy,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef
| ) |  | `[inline, static]`

Generates coordinates of a 2D unstructured grid embedded in 3D from a regular grid with grid directions parallel to the first two coordinate axes and equidistantly arranged nodes in all directions. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Minimal value of x coordinate of the generated grid.
  maxxRef | Maximal value of x coordinate of the generated grid.
  minyRef | Minimal value of y coordinate of the generated grid.
  maxyRef | Maximal value of y coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates2dPlain | ( | Field< vec3 > | field,
|  | int | dimx,
|  | int | dimy,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef,
|  | IFunc2d | fx,
|  | IFunc2d | fy,
|  | IFunc2d | fz
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  minyRef | Lower bound for the second parameter in the reference coordinate system.
  maxyRef | Upper bound for the second parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates2d | ( | Field< vec3 > | field,
|  | int | dimx,
|  | int | dimy,
|  | double | minxRef,
|  | double | maxxRef,
|  | double | minyRef,
|  | double | maxyRef,
|  | IFunc2d | fx,
|  | IFunc2d | fy,
|  | IFunc2d | fz
| ) |  | `[inline, static]`

Generates coordinates of a 3D unstructured grid of a parametric volume according to functions specifying the x, y, and z coordinates in terms of three scalar functions of 3 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  dimy | Number of nodes in y direction.
  dimz | Number of nodes in z direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  minyRef | Lower bound for the second parameter in the reference coordinate system.
  maxyRef | Upper bound for the second parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates1dPlain | ( | Field< vec3 > | field,
|  | int | dimx,
|  | double | minxRef,
|  | double | maxxRef
| ) |  | `[inline, static]`

Generates coordinates of a 1D unstructured grid from a regular grid with grid direction parallel to X coordinate axes and equidistantly arranged nodes. This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  minxRef | Minimal value of x coordinate of the generated grid.
  maxxRef | Maximal value of x coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates1d | ( | Field< vec3 > | field,
|  | int | dimx,
|  | double | minxRef,
|  | double | maxxRef
| ) |  | `[inline, static]`

Generates coordinates of a 1D unstructured grid from a regular grid with grid direction parallel to X coordinate axis and equidistantly arranged nodes. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  minxRef | Minimal value of x coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates1dPlain | ( | Field< vec3 > | field,
|  | int | dimx,
|  | double | minxRef,
|  | double | maxxRef,
|  | IRealFunction | fx,
|  | IRealFunction | fy,
|  | IRealFunction | fz
| ) |  | `[inline, static]`

Generates coordinates of a 1D unstructured grid of a parametric curve according to functions specifying the x, y, and z coordinates in terms of three functions of 1 variable. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates1d | ( | Field< vec3 > | field,
|  | int | dimx,
|  | double | minxRef,
|  | double | maxxRef,
|  | IRealFunction | fx,
|  | IRealFunction | fy,
|  | IRealFunction | fz
| ) |  | `[inline, static]`

Generates coordinates of a 1D unstructured grid of a parametric curve according to functions specifying the x, y, and z coordinates in terms of three functions of 1 variables. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.
  fz | Function that maps node coordinates of the reference grid to the third node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates1dPlain | ( | Field< vec2 > | field,
|  | int | dimx,
|  | double | minxRef,
|  | double | maxxRef
| ) |  | `[inline, static]`

Generates coordinates of a 1D unstructured grid embedded in 2D space from a regular grid with grid direction parallel to X coordinate axes and equidistantly arranged nodes. This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  minxRef | Minimal value of x coordinate of the generated grid.
  maxxRef | Maximal value of x coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates | ( | Field< vec2 > | field,
|  | int | dimx,
|  | double | minxRef,
|  | double | maxxRef
| ) |  | `[inline, static]`

Generates coordinates of a 1D unstructured grid embedded in 2D space from a regular grid with grid direction parallel to X coordinate axis and equidistantly arranged nodes. Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  minxRef | Minimal value of x coordinate of the generated grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates1dPlain | ( | Field< vec2 > | field,
|  | int | dimx,
|  | double | minxRef,
|  | double | maxxRef,
|  | IRealFunction | fx,
|  | IRealFunction | fy
| ) |  | `[inline, static]`

Generates coordinates of a 1D unstructured grid embedded in 2D space of a parametric curve according to functions specifying the x, and y coordinates in terms of 2 functions of 1 variable. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.This is plain version of the method that does not check consistency of dimension or existence of objects.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::GenerateCoordinates1d | ( | Field< vec2 > | field,
|  | int | dimx,
|  | double | minxRef,
|  | double | maxxRef,
|  | IRealFunction | fx,
|  | IRealFunction | fy
| ) |  | `[inline, static]`

Generates coordinates of a 1D unstructured grid embedded in 2D space of a parametric curve according to functions specifying the x, and y coordinates in terms of 2 functions of 1 variable. Coordinates are obtained by transforming individual coordinates of a regular equidistant grid from the reference system.. Numbers of nodes in each grid directions are specified by current dimensions of the grid.Consistency of dimensions and existence of objects are checked and exceptions are thrown when checks fail.

Parameters:

  field | Field for which coordinates are generated. Dimensions must be set and array of vector values allocated before this function is called.
  dimx | Number of nodes in x direction.
  minxRef | Lower bound for the first parameter in the reference coordinate system.
  maxxRef | Upper bound for the first parameter in the reference coordinate system.
  fx | Function that maps node coordinates of the reference grid to the first node coordinates' component of the actual grid.
  fy | Function that maps node coordinates of the reference grid to the second node coordinates' component of the actual grid.

template<TElement >

static void IG::Num::Field< TElement >::Example | ( |  | ) | `[inline, static]`

## Member Data Documentation

template<TElement >

string IG::Num::Field< TElement >::_name`[private]`

template<TElement >

string IG::Num::Field< TElement >::_description`[private]`

template<TElement >

TElement [] IG::Num::Field< TElement >::_values`[protected]`

template<TElement >

int IG::Num::Field< TElement >::_length`[private]`

## Property Documentation

template<TElement >

string IG::Num::Field< TElement >::Name`[get, set]`

Name of the field.

template<TElement >

string IG::Num::Field< TElement >::Description`[get, set]`

Description of the field.

template<TElement >

virtual TElement [] IG::Num::Field< TElement >::Values`[get, set]`

Array of field values.

Reimplemented in IG::Num::Field< TElement >::ExampleClassScalarField.

template<TElement >

int IG::Num::Field< TElement >::Length`[get, set]`

Number of elements.

template<TElement >

TElement IG::Num::Field< TElement >::this[int index]`[get, set]`

Access to elements through element index.

Parameters:

  index | Index running from 0 to Length

Reimplemented in IG::Num::StructuredField2d< TElement >, and IG::Num::StructuredField3d< TElement >.

The documentation for this class was generated from the following file:

- FieldGeneric.cs

All Classes Namespaces Files Functions Variables Enumerations Properties Events