FeatureThetaU¶

class FeatureThetaU(*args, **kwargs)¶

Bases: BasicFeature

Class that defines a 3D visual feature \(s\) from a \(\theta u\) axis/angle parametrization that represent the rotation between to frames.

Let us denote \(\theta u = (\theta u_x, \theta u_y, \theta u_z)\) .

It is convenient to consider two coordinate frames: the current camera frame \({\cal{F}}_c\) and the desired camera frame \({\cal{F}}_{c^*}\) .

Let \(^{c^*}R_c\) be the rotation matrix that gives the orientation of the current camera frame relative to the desired camera frame. Let \(\theta u_{^{c^*}R_c}\) to corresponding axis/angle representation of this rotation.

Furthermore, let \(^{c}R_{c^*}\) the rotation matrix that gives the orientation of the desired camera frame relative to the current camera frame. Let \(\theta u_{^{c}R_{c^*}}\) to corresponding axis/angle representation of this rotation.

This class can be used to manipulate two kind of visual features:

\(s = \theta u_{^{c^*}R_c}\) if the orientation of current camera frame relative to the desired frame has to be considered. The desired visual feature \(s^*\) is equal to zero. The corresponding error is than equal to \(e=(s-s^*) = \theta u_{^{c^*}R_c}\) . In this case, the interaction matrix related to \(s\) is given by

\[L = \left[ \begin{array}{cc} 0_3 & L_{\theta u} \end{array} \right] \]

with

\[L_{\theta u} = I_3 + \frac{\theta}{2} \; [u]_\times + \left(1 - \frac{sinc \theta}{sinc^2 \frac{\theta}{2}}\right) [u]^2_\times \]

where \(0_3\) is a \(3 \times 3\) nul matrix, \(I_3\) is the \(3 \times 3\) identity matrix, and for more readability \(\theta\) and \(u\) respectively the angle and the axis coordinates of the \(\theta u_{^{c^*}R_c}\) representation.

\(s = \theta u_{^{c}R_{c^*}}\) if it is more the orientation of the desired camera frame relative to the current frame that has to be considered. The desired visual feature \(s^*\) is equal to zero. The corresponding error is than equal to \(e=(s-s^*) = \theta u_{^{c}R_{c^*}}\) . In this case, the interaction matrix related to \(s\) is given by

\[L = \left[ \begin{array}{cc} 0_3 & L_{\theta u} \end{array} \right] \]

with

\[L_{\theta u} = -I_3 + \frac{\theta}{2} \; [u]_\times - \left(1 - \frac{sinc \theta}{sinc^2 \frac{\theta}{2}}\right) [u]^2_\times \]

The kind of visual feature is to set during the construction of the vpFeatureThetaU() object by using the selector vpFeatureThetaU::vpFeatureThetaURotationRepresentationType .

To initialize the feature \((\theta u_x, \theta u_y, \theta u_z)\) you may use vpFeatureThetaU member functions like set_TUx() , set_TUy() , set_TUz() , or also build() functions.

Depending on the choice of the visual feature representation, the interaction() method allows to compute the interaction matrix \(L\) associated to the visual feature, while the error() method computes the error vector \((s - s^*)\) between the current visual feature and the desired one.

To know more on the \(\theta u\) axis/angle representation for a 3D rotation see the vpThetaUVector class.

The code below shows how to create a eye-in hand visual servoing task using a 3D \(\theta u\) feature \((\theta u_x,\theta u_y, \theta u_z)\) that correspond to the 3D rotation between the current camera frame and the desired camera frame. To control six degrees of freedom, at least three other features must be considered like vpFeatureTranslation visual features. First we create a current ( \(s\) ) 3D \(\theta u\) feature, than set the task to use the interaction matrix associated to the current feature \(L_s\) and than compute the camera velocity \(v=-\lambda \; L_s^+ \; (s-s^*)\) . The current feature \(s\) is updated in the while() loop while \(s^*\) is considered as zero.

#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/visual_features/vpFeatureThetaU.h>
#include <visp3/vs/vpServo.h>

#ifdef ENABLE_VISP_NAMESPACE
using namespace VISP_NAMESPACE_NAME;
#endif

int main()
{
  vpServo task; // Visual servoing task

  vpHomogeneousMatrix cMcd;
  // ... cMcd need here to be initialized from for example a pose estimation.

  // Creation of the current feature s that correspond to the rotation
  // in angle/axis parametrization between the current camera frame
  // and the desired camera frame
  vpFeatureThetaU s(vpFeatureThetaU::cRcd);
  s.buildFrom(cMcd); // Initialization of the feature

  // Set eye-in-hand control law.
  // The computed velocities will be expressed in the camera frame
  task.setServo(vpServo::EYEINHAND_CAMERA);
  // Interaction matrix is computed with the current visual features s
  task.setInteractionMatrixType(vpServo::CURRENT);

  // Add the 3D ThetaU feature to the task
  task.addFeature(s); // s* is here considered as zero

  // Control loop
  for ( ; ; ) {
    // ... cMcd need here to be initialized from for example a pose estimation.

    // Update the current ThetaU visual feature
    s.buildFrom(cMcd);

    // compute the control law
    vpColVector v = task.computeControlLaw(); // camera velocity
  }
}

If you want to deal only with the \((\theta u_x,\theta u_y)\) subset feature from the 3D \(\theta u\) , you have just to modify the addFeature() call in the previous example by the following line. In that case, the dimension of \(s\) is two.

// Add the (ThetaU_x, ThetaU_y) subset features from the 3D ThetaU
// rotation to the task
task.addFeature(s, vpFeatureThetaU::selectTUx() | vpFeatureThetaU::selectTUy());

If you want to build your own control law, this other example shows how to create a current ( \(s\) ) and desired ( \(s^*\) ) 3D \(\theta u\) visual feature, compute the corresponding error vector \((s-s^*)\) and finally build the interaction matrix \(L_s\) .

#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/core/vpMatrix.h>
#include <visp3/visual_features/vpFeatureThetaU.h>

#ifdef ENABLE_VISP_NAMESPACE
using namespace VISP_NAMESPACE_NAME;
#endif

int main()
{
  vpHomogeneousMatrix cdMc;
  // ... cdMc need here to be initialized from for example a pose estimation.

  // Creation of the current feature s
  vpFeatureThetaU s(vpFeatureThetaU::cdRc);
  s.buildFrom(cdMc); // Initialization of the feature

  // Creation of the desired feature s*. By default this feature is
  // initialized to zero
  vpFeatureThetaU s_star(vpFeatureThetaU::cdRc);

  // Compute the interaction matrix L_s for the current ThetaU feature
  vpMatrix L = s.interaction();

  // Compute the error vector (s-s*) for the ThetaU feature
  s.error(s_star);
}

Overloaded function.

__init__(self: visp._visp.visual_features.FeatureThetaU) -> None

Constructor that builds a visual feature and initialize it to zero. The rotation representation of the \(\theta u\) visual feature will be vpFeatureThetaU::cdRc by default. Use the function setFeatureThetaURotationType() to set the desired type of feature.

__init__(self: visp._visp.visual_features.FeatureThetaU, r: visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType) -> None
__init__(self: visp._visp.visual_features.FeatureThetaU, tu: visp._visp.core.ThetaUVector, r: visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType) -> None

Constructor that build a 3D visual feature from a \(\theta u\) vector that represent the rotation \(R\) the camera has to achieve.

Parameters:

tu: [in] : Rotation that the camera has to achieve in \(\theta u\) angle/axis representation. Depending on the rotation representation type ( vpFeatureThetaU::vpFeatureThetaURotationRepresentationType ) used to construct this object, the parameter tu represents either the rotation that the camera has to achieve to move from the desired camera frame to the current one ( \(^{c^*}R_c\) ), or the rotation that the camera has to achieve to move from the current camera frame to the desired one ( \(^{c}R_{c^*}\) ).
r: [in] : The rotation representation of \(\theta u\) .

__init__(self: visp._visp.visual_features.FeatureThetaU, R: visp._visp.core.RotationMatrix, r: visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType) -> None

Constructor that build a 3D \(\theta u\) visual feature from a rotation matrix \(R\) that represent the rotation that the camera has to achieve.

Parameters:

R: [in] : Rotation that the camera has to achieve. Depending on r this rotation represent either the rotation that the camera has to achieve to move from the desired camera frame to the current one ( \(^{c^*}R_c\) ), or the rotation that the camera has to achieve to move from the current camera frame to the desired one ( \(^{c}R_{c^*}\) ).
r: [in] : The rotation representation of R.

__init__(self: visp._visp.visual_features.FeatureThetaU, M: visp._visp.core.HomogeneousMatrix, r: visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType) -> None

Constructor that build a 3D \(\theta u\) visual feature from an homogeneous matrix \(M\) that represent the displacement that the camera has to achieve.

Parameters:

M: [in] : Homogeneous transformation that describe the movement that the camera has to achieve. Only the rotational part of this homogeneous transformation is taken into consideration. Depending on r the rotation represent either the rotation that the camera has to achieve to move from the desired camera frame to the current one ( \(^{c^*}R_c\) ), or the rotation that the camera has to achieve to move from the current camera frame to the desired one ( \(^{c}R_{c^*}\) ).
r: [in] : The rotation representation of M.

Methods

`__init__`	Overloaded function.
`buildFrom`	Overloaded function.
`display`	Overloaded function.
`error`	Overloaded function.
`getFeatureThetaURotationType`	Get the type of rotation feature.
`get_TUx`	Return the \(\theta u_x\) subset value of the visual feature \(s\) .
`get_TUy`	Return the \(\theta u_y\) subset value of the visual feature \(s\) .
`get_TUz`	Return the \(\theta u_z\) subset value of the visual feature \(s\) .
`init`	Initialise the memory space requested for 3D \(\theta u\) visual feature.
`interaction`	Compute and return the interaction matrix \(L\) from a subset ( \(\theta u_x, \theta u_y, \theta u_z\) ) of the possible \(\theta u\) features that represent the 3D rotation \(^{c^}R_c\) or \(^{c}R_{c^}\) , with
`print`	Print to stdout the values of the current visual feature \(s\) .
`selectTUx`	Function used to select the \(\theta u_x\) subset of the \(\theta u\) visual feature.
`selectTUy`	Function used to select the \(\theta u_y\) subset of the \(\theta u\) visual feature.
`selectTUz`	Function used to select the \(\theta u_z\) subset of the \(\theta u\) visual feature.
`setFeatureThetaURotationType`
`set_TUx`	Initialise the \(\theta u_x\) subset value of the 3D visual feature \(s\) .
`set_TUy`	Initialise the \(\theta u_y\) subset value of the 3D visual feature \(s\) .
`set_TUz`	Initialise the \(\theta u_z\) subset value of the 3D visual feature \(s\) .

Inherited Methods

`vpServo`
`BasicFeatureSelect`	Indicates who should deallocate the feature.
`deallocate`
`dimension_s`	Return the dimension of the feature vector \(\bf s\) .
`s`
`user`
`getDeallocate`
`nbParameters`
`BasicFeatureDeallocatorType`	Indicates who should deallocate the feature.
`selectAll`	Select all the features.
`setDeallocate`
`dim_s`
`get_s`	Get the feature vector \(\bf s\) .
`FEATURE_ALL`
`setFlags`	Set feature flags to true to prevent warning when re-computing the interaction matrix without having updated the feature.
`getDimension`	Get the feature vector dimension.

Operators

`__doc__`
`__init__`	Overloaded function.
`__module__`

Attributes

`FEATURE_ALL`
`TUx`
`TUy`
`TUz`
`__annotations__`
`cRcd`
`cdRc`
`deallocate`
`dim_s`
`nbParameters`
`s`
`user`
`vpServo`

class BasicFeatureDeallocatorType(self, value: int)¶

Bases: pybind11_object

Indicates who should deallocate the feature.

Values:

user
vpServo

__and__(self, other: object) → object¶

__eq__(self, other: object) → bool¶

__ge__(self, other: object) → bool¶

__getstate__(self) → int¶

__gt__(self, other: object) → bool¶

__hash__(self) → int¶

__index__(self) → int¶

__init__(self, value: int)¶

__int__(self) → int¶

__invert__(self) → object¶

__le__(self, other: object) → bool¶

__lt__(self, other: object) → bool¶

__ne__(self, other: object) → bool¶

__or__(self, other: object) → object¶

__rand__(self, other: object) → object¶

__ror__(self, other: object) → object¶

__rxor__(self, other: object) → object¶

__setstate__(self, state: int) → None¶

__xor__(self, other: object) → object¶

property name : str¶

class BasicFeatureSelect(self, value: int)¶

Bases: pybind11_object

Indicates who should deallocate the feature.

Values:

user
vpServo

__and__(self, other: object) → object¶

__eq__(self, other: object) → bool¶

__ge__(self, other: object) → bool¶

__getstate__(self) → int¶

__gt__(self, other: object) → bool¶

__hash__(self) → int¶

__index__(self) → int¶

__init__(self, value: int)¶

__int__(self) → int¶

__invert__(self) → object¶

__le__(self, other: object) → bool¶

__lt__(self, other: object) → bool¶

__ne__(self, other: object) → bool¶

__or__(self, other: object) → object¶

__rand__(self, other: object) → object¶

__ror__(self, other: object) → object¶

__rxor__(self, other: object) → object¶

__setstate__(self, state: int) → None¶

__xor__(self, other: object) → object¶

property name : str¶

class FeatureThetaURotationRepresentationType(self, value: int)¶

Bases: pybind11_object

Values:

cdRc: Selector used to manipulate the visual feature \(s = \theta u_{^{c^*}R_c}\) . This visual feature represent the orientation of the current camera frame relative to the desired camera frame.
cRcd: Selector used to manipulate the visual feature \(s = \theta u_{^{c}R_{c^*}}\) . This visual feature represent the orientation of the desired camera frame relative to the current camera frame.

__and__(self, other: object) → object¶

__eq__(self, other: object) → bool¶

__ge__(self, other: object) → bool¶

__getstate__(self) → int¶

__gt__(self, other: object) → bool¶

__hash__(self) → int¶

__index__(self) → int¶

__init__(self, value: int)¶

__int__(self) → int¶

__invert__(self) → object¶

__le__(self, other: object) → bool¶

__lt__(self, other: object) → bool¶

__ne__(self, other: object) → bool¶

__or__(self, other: object) → object¶

__rand__(self, other: object) → object¶

__ror__(self, other: object) → object¶

__rxor__(self, other: object) → object¶

__setstate__(self, state: int) → None¶

__xor__(self, other: object) → object¶

property name : str¶

class FeatureThetaUType(self, value: int)¶

Bases: pybind11_object

Values:

cdRc: Selector used to manipulate the visual feature \(s = \theta u_{^{c^*}R_c}\) . This visual feature represent the orientation of the current camera frame relative to the desired camera frame.
cRcd: Selector used to manipulate the visual feature \(s = \theta u_{^{c}R_{c^*}}\) . This visual feature represent the orientation of the desired camera frame relative to the current camera frame.

__and__(self, other: object) → object¶

__eq__(self, other: object) → bool¶

__ge__(self, other: object) → bool¶

__getstate__(self) → int¶

__gt__(self, other: object) → bool¶

__hash__(self) → int¶

__index__(self) → int¶

__init__(self, value: int)¶

__int__(self) → int¶

__invert__(self) → object¶

__le__(self, other: object) → bool¶

__lt__(self, other: object) → bool¶

__ne__(self, other: object) → bool¶

__or__(self, other: object) → object¶

__rand__(self, other: object) → object¶

__ror__(self, other: object) → object¶

__rxor__(self, other: object) → object¶

__setstate__(self, state: int) → None¶

__xor__(self, other: object) → object¶

property name : str¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: visp._visp.visual_features.FeatureThetaU) -> None

__init__(self: visp._visp.visual_features.FeatureThetaU, r: visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType) -> None
__init__(self: visp._visp.visual_features.FeatureThetaU, tu: visp._visp.core.ThetaUVector, r: visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType) -> None

Constructor that build a 3D visual feature from a \(\theta u\) vector that represent the rotation \(R\) the camera has to achieve.

Parameters:

tu: [in] : Rotation that the camera has to achieve in \(\theta u\) angle/axis representation. Depending on the rotation representation type ( vpFeatureThetaU::vpFeatureThetaURotationRepresentationType ) used to construct this object, the parameter tu represents either the rotation that the camera has to achieve to move from the desired camera frame to the current one ( \(^{c^*}R_c\) ), or the rotation that the camera has to achieve to move from the current camera frame to the desired one ( \(^{c}R_{c^*}\) ).
r: [in] : The rotation representation of \(\theta u\) .

__init__(self: visp._visp.visual_features.FeatureThetaU, R: visp._visp.core.RotationMatrix, r: visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType) -> None

Constructor that build a 3D \(\theta u\) visual feature from a rotation matrix \(R\) that represent the rotation that the camera has to achieve.

Parameters:

R: [in] : Rotation that the camera has to achieve. Depending on r this rotation represent either the rotation that the camera has to achieve to move from the desired camera frame to the current one ( \(^{c^*}R_c\) ), or the rotation that the camera has to achieve to move from the current camera frame to the desired one ( \(^{c}R_{c^*}\) ).
r: [in] : The rotation representation of R.

__init__(self: visp._visp.visual_features.FeatureThetaU, M: visp._visp.core.HomogeneousMatrix, r: visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType) -> None

Constructor that build a 3D \(\theta u\) visual feature from an homogeneous matrix \(M\) that represent the displacement that the camera has to achieve.

Parameters:

M: [in] : Homogeneous transformation that describe the movement that the camera has to achieve. Only the rotational part of this homogeneous transformation is taken into consideration. Depending on r the rotation represent either the rotation that the camera has to achieve to move from the desired camera frame to the current one ( \(^{c^*}R_c\) ), or the rotation that the camera has to achieve to move from the current camera frame to the desired one ( \(^{c}R_{c^*}\) ).
r: [in] : The rotation representation of M.

buildFrom(*args, **kwargs)¶

Overloaded function.

buildFrom(self: visp._visp.visual_features.FeatureThetaU, tu: visp._visp.core.ThetaUVector) -> visp._visp.visual_features.FeatureThetaU

Build a 3D visual feature from a \(\theta u\) vector that represent the rotation \(R\) the camera has to achieve.

Parameters:

tu: [in] : Rotation that the camera has to achieve in \(\theta u\) angle/axis representation. Depending on the rotation representation type ( vpFeatureThetaU::vpFeatureThetaURotationRepresentationType ) used to construct this object, the parameter tu represents either the rotation that the camera has to achieve to move from the desired camera frame to the current one ( \(^{c^*}R_c\) ), or the rotation that the camera has to achieve to move from the current camera frame to the desired one ( \(^{c}R_{c^*}\) ).

buildFrom(self: visp._visp.visual_features.FeatureThetaU, R: visp._visp.core.RotationMatrix) -> visp._visp.visual_features.FeatureThetaU

Build a 3D \(\theta u\) visual feature from a rotation matrix \(R\) that represent the rotation that the camera has to achieve.

Parameters:

R: [in] : Rotation that the camera has to achieve. Depending on the rotation representation type ( vpFeatureThetaU::vpFeatureThetaURotationRepresentationType ) used to construct this object, the parameter R represents either the rotation that the camera has to achieve to move from the desired camera frame to the current one ( \(^{c^*}R_c\) ), or the rotation that the camera has to achieve to move from the current camera frame to the desired one ( \(^{c}R_{c^*}\) ).

buildFrom(self: visp._visp.visual_features.FeatureThetaU, M: visp._visp.core.HomogeneousMatrix) -> visp._visp.visual_features.FeatureThetaU

Build a 3D \(\theta u\) visual feature from an homogeneous matrix \(M\) that represent the displacement that the camera has to achieve.

Parameters:

M: [in] : Homogeneous transformation that describe the movement that the camera has to achieve. Only the rotational part of this homogeneous transformation is taken into consideration. Depending on the rotation representation type ( vpFeatureThetaU::vpFeatureThetaURotationRepresentationType ) used to construct this object, the parameter M represents either the rotation that the camera has to achieve to move from the desired camera frame to the current one ( \(^{c^*}R_c\) ), or the rotation that the camera has to achieve to move from the current camera frame to the desired one ( \(^{c}R_{c^*}\) ).

dimension_s(self) → int¶: Return the dimension of the feature vector \(\bf s\) .

display(*args, **kwargs)¶

Overloaded function.

display(self: visp._visp.visual_features.FeatureThetaU, cam: visp._visp.core.CameraParameters, I: visp._visp.core.ImageGray, color: visp._visp.core.Color = vpColor::green, thickness: int = 1) -> None

Not implemented.

display(self: visp._visp.visual_features.FeatureThetaU, cam: visp._visp.core.CameraParameters, I: visp._visp.core.ImageRGBa, color: visp._visp.core.Color = vpColor::green, thickness: int = 1) -> None

Not implemented.

error(*args, **kwargs)¶

Overloaded function.

error(self: visp._visp.visual_features.FeatureThetaU, s_star: visp._visp.visual_features.BasicFeature, select: int = FEATURE_ALL) -> visp._visp.core.ColVector

Compute the error \((s-s^*)\) between the current and the desired visual features from a subset of the possible features.

Since this visual feature \(s\) represent either the rotation from the desired camera frame to the current camera frame \(^{c^*}R_{c}\) , or the rotation from the current camera frame to the desired camera frame \(^{c}R_{c^*}\) , the desired visual feature \(s^*\) should be zero. Thus, the error is here equal to the current visual feature \(s\) .

The code below shows how to use this method to manipulate the \(\theta u_z\) subset:

// Creation of the current feature s
vpFeatureThetaU s(vpFeatureThetaU::cdRc);
s.set_TUz(0.3);

// Creation of the desired feature s^*. By default this feature is
// initialized to zero
vpFeatureThetaU s_star(vpFeatureThetaU::cdRc);

// Compute the interaction matrix for the ThetaU_z feature
vpMatrix L_z = s.interaction( vpFeatureThetaU::selectTUz() );

// Compute the error vector (s-s*) for the ThetaU_z feature
s.error(s_star, vpFeatureThetaU::selectTUz());

To manipulate the subset features \(s=(\theta u_y, \theta u_z)\) , the code becomes:

// Compute the interaction matrix for the ThetaU_y, ThetaU_z features
vpMatrix L_yz = s.interaction( vpFeatureThetaU::selectTUy() |
vpFeatureThetaU::selectTUz() );

// Compute the error vector e = (s-s*) for the ThetaU_y, ThetaU_z feature
vpColVector e = s.error(s_star, vpFeatureThetaU::selectTUy() | vpFeatureThetaU::selectTUz());

Parameters:

s_star

Desired visual visual feature that should be equal to zero.

select

The error can be computed for a selection of a subset of the possible \(\theta u\) features.

To compute the error for all the three \(\theta u\) features use vpBasicFeature::FEATURE_ALL . In that case the error vector is a 3 dimension column vector.
To compute the error for only one of the \(\theta u\) component feature ( \(\theta u_x, \theta u_y, \theta u_z\) ) use one of the corresponding function selectTUx() , selectTUy() or selectTUz() . In that case the error vector is a 1 dimension column vector.

Returns:

The error \((s-s^*)\) between the current and the desired visual feature.

error(self: visp._visp.visual_features.BasicFeature, s_star: visp._visp.visual_features.BasicFeature, select: int = FEATURE_ALL) -> visp._visp.core.ColVector

Compute the error between two visual features from a subset of the possible features.

getDeallocate(self) → visp._visp.visual_features.BasicFeature.BasicFeatureDeallocatorType¶

getDimension(self, select: int = FEATURE_ALL) → int¶: Get the feature vector dimension.

getFeatureThetaURotationType(self) → visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType¶

Get the type of rotation feature.

Note

See setFeatureThetaURotationType()

Returns:: Type of rotation feature. It can be vpFeatureThetaU::cdRc or vpFeatureThetaU::cRcd .

get_TUx(self) → float¶: Return the \(\theta u_x\) subset value of the visual feature \(s\) .

get_TUy(self) → float¶: Return the \(\theta u_y\) subset value of the visual feature \(s\) .

get_TUz(self) → float¶: Return the \(\theta u_z\) subset value of the visual feature \(s\) .

get_s(self, select: int = FEATURE_ALL) → visp._visp.core.ColVector¶: Get the feature vector \(\bf s\) .

init(self) → None¶: Initialise the memory space requested for 3D \(\theta u\) visual feature.

interaction(self, select: int = FEATURE_ALL) → visp._visp.core.Matrix¶

Compute and return the interaction matrix \(L\) from a subset ( \(\theta u_x, \theta u_y, \theta u_z\) ) of the possible \(\theta u\) features that represent the 3D rotation \(^{c^*}R_c\) or \(^{c}R_{c^*}\) , with

\[L = [ 0_3 \; L_{\theta u}] \]

See the vpFeatureThetaU class description for the equations of \(L_{\theta u}\) .

The code below shows how to compute the interaction matrix associated to the visual feature \(s = \theta u_x\) .

vpRotationMatrix cdMc;

// Creation of the current feature s
vpFeatureThetaU s(vpFeatureThetaU::cdRc);
s.buildFrom(cdMc);

vpMatrix L_x = s.interaction( vpFeatureThetaU::selectTUx() );

The code below shows how to compute the interaction matrix associated to the \(s = (\theta u_x, \theta u_y)\) subset visual feature:

vpMatrix L_xy = s.interaction( vpFeatureThetaU::selectTUx() | vpFeatureThetaU::selectTUy() );

L_xy is here now a 2 by 6 matrix. The first line corresponds to the \(\theta u_x\) visual feature while the second one to the \(\theta u_y\) visual feature.

It is also possible to build the interaction matrix from all the \(\theta u\) components by:

vpMatrix L_xyz = s.interaction( vpBasicFeature::FEATURE_ALL );

In that case, L_xyz is a 3 by 6 interaction matrix where the last line corresponds to the \(\theta u_z\) visual feature.

Parameters:

select: int = FEATURE_ALL¶

Selection of a subset of the possible \(\theta u\) features.

To compute the interaction matrix for all the three \(\theta u\) features use vpBasicFeature::FEATURE_ALL . In that case the dimension of the interaction matrix is \([3 \times 6]\)
To compute the interaction matrix for only one of the \(\theta u\) component feature ( \(\theta u_x, \theta u_y, \theta u_z\) ) use one of the corresponding function selectTUx() , selectTUy() or selectTUz() . In that case the returned interaction matrix is \([1 \times 6]\) dimension.

Returns:

The interaction matrix computed from the \(\theta u\) features that represent either the rotation \(^{c^*}R_c\) or the rotation \(^{c}R_{c^*}\) .

print(self, select: int = FEATURE_ALL) → None¶

Print to stdout the values of the current visual feature \(s\) .

vpThetaUVector tu; // Current visual feature s
tu[0] = 0.1;
tu[1] = 0.2;
tu[2] = 0.3;

// Creation of the current feature s
vpFeatureThetaU s(vpFeatureThetaU::cdRc);
s.buildFrom(tu);

s.print(); // print all the 3 components of the feature
s.print(vpBasicFeature::FEATURE_ALL);  // same behavior then previous line
s.print(vpFeatureThetaU::selectTUz()); // print only the ThetaU_z component

Parameters:

select: int = FEATURE_ALL¶

Selection of a subset of the possible \(\theta u\) features.

To print all the three \(\theta u\) features use vpBasicFeature::FEATURE_ALL .
To print only one of the \(\theta u\) component feature ( \(\theta u_x, \theta u_y, \theta u_z\) ) use one of the corresponding function selectTUx() , selectTUy() or selectTUz() .

static selectAll() → int¶: Select all the features.

static selectTUx() → int¶

Function used to select the \(\theta u_x\) subset of the \(\theta u\) visual feature.

This function is to use in conjunction with interaction() in order to compute the interaction matrix associated to \(\theta u_x\) .

See the interaction() method for an usage example.

This function is also useful in the vpServo class to indicate that a subset of the visual feature is to use in the control law:

vpFeatureThetaU tu;
vpServo task;
...
// Add the (ThetaU_x, ThetaU_y) subset features from the 3D ThetaU
// rotation to the task
task.addFeature(tu, vpFeatureThetaU::selectTUx() | vpFeatureThetaU::selectTUy());

Note

See selectTUy() , selectTUz()

static selectTUy() → int¶

Function used to select the \(\theta u_y\) subset of the \(\theta u\) visual feature.

This function is to use in conjunction with interaction() in order to compute the interaction matrix associated to \(\theta u_y\) .

See the interaction() method for an usage example.

This function is also useful in the vpServo class to indicate that a subset of the visual feature is to use in the control law:

vpFeatureThetaU tu;
vpServo task;
...
// Add the (ThetaU_x, ThetaU_y) subset features from the 3D ThetaU
// rotation to the task
task.addFeature(tu, vpFeatureThetaU::selectTUx() | vpFeatureThetaU::selectTUy());

Note

See selectTUx() , selectTUz()

static selectTUz() → int¶

Function used to select the \(\theta u_z\) subset of the \(\theta u\) visual feature.

This function is to use in conjunction with interaction() in order to compute the interaction matrix associated to \(\theta u_z\) .

See the interaction() method for an usage example.

This function is also useful in the vpServo class to indicate that a subset of the visual feature is to use in the control law:

vpFeatureThetaU tu;
vpServo task;
...
// Add the (ThetaU_z) subset feature from the 3D ThetaU
// rotation to the task
task.addFeature(tu, vpFeatureThetaU::selectTUz());

Note

See selectTUx() , selectTUy()

setDeallocate(self, d: visp._visp.visual_features.BasicFeature.BasicFeatureDeallocatorType) → None¶

setFeatureThetaURotationType(self, r: visp._visp.visual_features.FeatureThetaU.FeatureThetaURotationRepresentationType) → None¶

setFlags(self) → None¶: Set feature flags to true to prevent warning when re-computing the interaction matrix without having updated the feature.

set_TUx(self, tu_x: float) → None¶

Initialise the \(\theta u_x\) subset value of the 3D visual feature \(s\) .

Note

See get_TUz()

Parameters:

tu_x: float¶: math:theta u_x subset value to initialize.

set_TUy(self, tu_y: float) → None¶

Initialise the \(\theta u_y\) subset value of the 3D visual feature \(s\) .

Note

See get_TUy()

Parameters:

tu_y: float¶: math:theta u_y subset value to initialize.

set_TUz(self, tu_z: float) → None¶

Initialise the \(\theta u_z\) subset value of the 3D visual feature \(s\) .

Note

See get_TUz()

Parameters:

tu_z: float¶: math:theta u_z subset value to initialize.