List Export Mesh to Matrix algorithms. More...

Collaboration diagram for Export Mesh to Matrix Algorithms:

Functions
template<MatrixConcept Matrix, EdgeMeshConcept MeshType>
Matrix	vcl::edgeColorsMatrix (const MeshType &mesh)
	Get a #E*4 Matrix of integers containing the colors of the edges of a Mesh. The function is templated on the Matrix itself.

template<typename Vect , MeshConcept MeshType>
Vect	vcl::edgeColorsVector (const MeshType &mesh, Color::Format colorFormat)
	Get a #E Vector of integers containing the colors of the edges of a Mesh. The function is templated on the Vector itself. The color is packed in a single 32 bit value using the provided format.

template<typename Vect , EdgeMeshConcept MeshType>
Vect	vcl::edgeQualityVector (const MeshType &mesh)
	Get a #E Vector of scalars containing the quality of the edges of a Mesh. The function is templated on the Vector itself.

template<MatrixConcept Matrix, EdgeMeshConcept MeshType>
Matrix	vcl::edgeVertexIndicesMatrix (const MeshType &mesh)
	Get a #F*LFS Matrix of integers containing the vertex indices for each face of a Mesh. LFS is the largest face size of the mesh (this number is variable only for polygonal meshes).

template<uint ELEM_ID, MatrixConcept Matrix, MeshConcept MeshType>
Matrix	vcl::elementColorsMatrix (const MeshType &mesh)
	Get a #E*4 Matrix of integers containing the colors of the elements identified by `ELEM_ID` of a Mesh. The function is templated on the Matrix itself.

template<uint ELEM_ID, typename Vect , MeshConcept MeshType>
Vect	vcl::elementColorsVector (const MeshType &mesh, Color::Format colorFormat)
	Get a #E Vector of integers containing the colors of the elements identified by `ELEM_ID` of a Mesh. The function is templated on the Vector itself. The color is packed in a single 32 bit value using the provided format.

template<uint ELEM_ID, MatrixConcept Matrix, MeshConcept MeshType>
Matrix	vcl::elementNormalsMatrix (const MeshType &mesh)
	Get a #E Vector of booleans (or integers) containing the selection status of the elements identified by `ELEM_ID` of a Mesh. The function is templated on the Vector itself.

template<uint ELEM_ID, typename Vect , MeshConcept MeshType>
Vect	vcl::elementQualityVector (const MeshType &mesh)
	Get a #E Vector of scalars containing the quality of the elements identified by `ELEM_ID` of a Mesh. The function is templated on the Vector itself.

template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix	vcl::faceColorsMatrix (const MeshType &mesh)
	Get a #F*4 Matrix of integers containing the colors of the faces of a Mesh. The function is templated on the Matrix itself.

template<typename Vect , MeshConcept MeshType>
Vect	vcl::faceColorsVector (const MeshType &mesh, Color::Format colorFormat)
	Get a #F Vector of integers containing the colors of the faces of a Mesh. The function is templated on the Vector itself. The color is packed in a single 32 bit value using the provided format.

template<typename Vect , FaceMeshConcept MeshType>
Vect	vcl::faceMaterialIndicesVector (const MeshType &mesh)
	Get a #F vector of scalars containing the material indices of the faces of a Mesh. The function is templated on the Vector itself.

template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix	vcl::faceNormalsMatrix (const MeshType &mesh)
	Get a #F*3 Matrix of scalars containing the normals of the faces of a Mesh. The function is templated on the Matrix itself.

template<typename Vect , FaceMeshConcept MeshType>
Vect	vcl::faceQualityVector (const MeshType &mesh)
	Get a #F Vector of scalars containing the quality of the faces of a Mesh. The function is templated on the Vector itself.

template<typename Vect , FaceMeshConcept MeshType>
Vect	vcl::faceVertexIndicesVector (const MeshType &mesh)
	Get a #V*3 Matrix of scalars containing the positions of the vertices of a Mesh. The function is templated on the Matrix itself.

template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix	vcl::faceWedgeTexCoordsMatrix (const MeshType &mesh)
	Get a #F(LFS2) Matrix of scalars containing the wedge texcoords of the faces of a Mesh. The function is templated on the Matrix itself. LFS is the largest face size of the mesh (this number is variable only for polygonal meshes).

template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix	vcl::vertexColorsMatrix (const MeshType &mesh)
	Get a #V*4 Matrix of integers containing the colors of the vertices of a Mesh. The function is templated on the Matrix itself.

template<typename Vect , MeshConcept MeshType>
Vect	vcl::vertexColorsVector (const MeshType &mesh, Color::Format colorFormat)
	Get a #V Vector of integers containing the colors of the vertices of a Mesh. The function is templated on the Vector itself. The color is packed in a single 32 bit value using the provided format.

template<typename Vect , MeshConcept MeshType>
Vect	vcl::vertexMaterialIndicesVector (const MeshType &mesh)
	Get a #V vector of scalars containing the material indices of the vertices of a Mesh. The function is templated on the Vector itself.

template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix	vcl::vertexNormalsMatrix (const MeshType &mesh)
	Get a #V*3 Matrix of scalars containing the normals of the vertices of a Mesh. The function is templated on the Matrix itself.

template<typename Vect , MeshConcept MeshType>
Vect	vcl::vertexQualityVector (const MeshType &mesh)
	Get a #V Vector of scalars containing the quality of the vertices of a Mesh. The function is templated on the Vector itself.

template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix	vcl::vertexTexCoordsMatrix (const MeshType &mesh)
	Get a #V*2 Matrix of scalars containing the texcoords of the vertices of a Mesh. The function is templated on the Matrix itself.

Detailed Description

List Export Mesh to Matrix algorithms.

They allow to export mesh data to matrices.

Function Documentation

◆ edgeColorsMatrix()

template<MatrixConcept Matrix, EdgeMeshConcept MeshType>

Matrix vcl::edgeColorsMatrix ( const MeshType & mesh )

Get a #E*4 Matrix of integers containing the colors of the edges of a Mesh. The function is templated on the Matrix itself.

This function works with every Matrix type that satisfies the MatrixConcept, and requires that the mesh has per-edge colors.

Usage example with Eigen Matrix:

Eigen::MatrixX4i EC = vcl::edgeColorsMatrix<Eigen::MatrixX4i>(myMesh);

vcl::Box

A class representing a box in N-dimensional space.

Definition box.h:46

Exceptions

vcl::MissingComponentException if the mesh does not have per-edge colors available.

Note: This function does not guarantee that the rows of the matrix correspond to the edge indices of the mesh. This scenario is possible when the mesh has deleted edges. To be sure to have a direct correspondence, compact the edge container before calling this function.

Parameters

[in] mesh input mesh

Returns: #E*4 matrix of integers (edge colors)

◆ edgeColorsVector()

template<typename Vect , MeshConcept MeshType>

Vect vcl::edgeColorsVector	(	const MeshType &	mesh,
		Color::Format	colorFormat
	)

Get a #E Vector of integers containing the colors of the edges of a Mesh. The function is templated on the Vector itself. The color is packed in a single 32 bit value using the provided format.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-edge colors.

Usage example with Eigen Vector:

Eigen::VectorXi EC =
    vcl::edgeColorsVector<Eigen::VectorXi>(
        myMesh, Color::Format::RGBA);

Exceptions

vcl::MissingComponentException if the mesh does not have per-edge colors available.

Note: This function does not guarantee that the rows of the vector correspond to the edge indices of the mesh. This scenario is possible when the mesh has deleted edges. To be sure to have a direct correspondence, compact the edge container before calling this function.

Parameters

[in] mesh input mesh

Returns: #E vector of integers (edge colors)

◆ edgeQualityVector()

template<typename Vect , EdgeMeshConcept MeshType>

Vect vcl::edgeQualityVector ( const MeshType & mesh )

Get a #E Vector of scalars containing the quality of the edges of a Mesh. The function is templated on the Vector itself.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-edge quality.

Usage example with Eigen Vector:

Eigen::VectorXd EQ = vcl::edgeQualityVector<Eigen::VectorXd>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-edge quality available.

Note: This function does not guarantee that the rows of the vector correspond to the edge indices of the mesh. This scenario is possible when the mesh has deleted edges. To be sure to have a direct correspondence, compact the edge container before calling this function.

Parameters

[in] mesh input mesh

Returns: #E vector of scalars (edge quality)

◆ edgeVertexIndicesMatrix()

template<MatrixConcept Matrix, EdgeMeshConcept MeshType>

Matrix vcl::edgeVertexIndicesMatrix ( const MeshType & mesh )

Get a #F*LFS Matrix of integers containing the vertex indices for each face of a Mesh. LFS is the largest face size of the mesh (this number is variable only for polygonal meshes).

If the mesh is polygonal, the matrix will have a number of rows equal to the greatest polygon of the mesh, and unused values will be set to -1.

This function works with every Matrix type that satisfies the MatrixConcept.

Usage example with Eigen Matrix:

   Eigen::MatrixXi F = vcl::faceVertexIndicesMatrix<Eigen::MatrixXi>(myMesh);
   @endif
  
   @throws vcl::MissingCompactnessException if the vertex container is not
   compact.
  
   @note This function does not guarantee that the rows of the matrix
   correspond to the face indices of the mesh. This scenario is possible
   when the mesh has deleted faces. To be sure to have a direct
   correspondence, compact the face container before calling this function.
  
   @tparam Matrix: type of the matrix to be returned, it must satisfy the
   MatrixConcept.
   @tparam MeshType: type of the input mesh, it must satisfy the
   FaceMeshConcept.
  
   @param[in] mesh: input mesh
   @return \#F*LFS matrix of vertex indices
  
   @ingroup export_matrix
  /
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix faceVertexIndicesMatrix(const MeshType& mesh)
{
    requireVertexContainerCompactness(mesh);
 
    uint fMaxSize = largestFaceSize(mesh);
 
    Matrix fM(mesh.faceNumber(), fMaxSize);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    faceVertexIndicesToBuffer(mesh, fM.data(), fMaxSize, stg);
 
    return fM;
}
 

Exceptions

vcl::MissingCompactnessException if the vertex container is not compact.

Note: This function does not guarantee that the rows of the matrix correspond to the edge indices of the mesh. This scenario is possible when the mesh has deleted edges. To be sure to have a direct correspondence, compact the edge container before calling this function.

Template Parameters

Matrix	type of the matrix to be returned, it must satisfy the MatrixConcept.
MeshType	type of the input mesh, it must satisfy the EdgeMeshConcept.

Parameters

[in] mesh input mesh

Returns: #E*2 matrix of integers (edge indices)

◆ elementColorsMatrix()

template<uint ELEM_ID, MatrixConcept Matrix, MeshConcept MeshType>

Matrix vcl::elementColorsMatrix ( const MeshType & mesh )

Get a #E*4 Matrix of integers containing the colors of the elements identified by ELEM_ID of a Mesh. The function is templated on the Matrix itself.

This function works with every Matrix type that satisfies the MatrixConcept, and requires that the mesh has per-element colors.

Usage example with Eigen Matrix:

Eigen::MatrixX4i EC =

vcl::elementColorsMatrix<ElemId::VERTEX, Eigen::MatrixX4i>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-element colors available.

Note: This function does not guarantee that the rows of the matrix correspond to the element indices of the mesh. This scenario is possible when the mesh has deleted elements. To be sure to have a direct correspondence, compact the element container before calling this function.

Template Parameters

ELEM_ID the ID of the element.

Parameters

[in] mesh input mesh

Returns: #E*4 matrix of integers (element colors)

◆ elementColorsVector()

template<uint ELEM_ID, typename Vect , MeshConcept MeshType>

Vect vcl::elementColorsVector	(	const MeshType &	mesh,
		Color::Format	colorFormat
	)

Get a #E Vector of integers containing the colors of the elements identified by ELEM_ID of a Mesh. The function is templated on the Vector itself. The color is packed in a single 32 bit value using the provided format.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-element colors.

Usage example with Eigen Vector:

Eigen::VectorXi EC =
    vcl::elementColorsVector<ElemId::VERTEX, Eigen::VectorXi>(
        myMesh, Color::Format::RGBA);

Exceptions

vcl::MissingComponentException if the mesh does not have per-element colors available.

Note: This function does not guarantee that the rows of the vector correspond to the element indices of the mesh. This scenario is possible when the mesh has deleted elements. To be sure to have a direct correspondence, compact the element container before calling this function.

Template Parameters

ELEM_ID the ID of the element.

Parameters

[in] mesh input mesh

Returns: #E vector of integers (element colors)

◆ elementNormalsMatrix()

template<uint ELEM_ID, MatrixConcept Matrix, MeshConcept MeshType>

Matrix vcl::elementNormalsMatrix ( const MeshType & mesh )

Get a #E Vector of booleans (or integers) containing the selection status of the elements identified by ELEM_ID of a Mesh. The function is templated on the Vector itself.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint].

Usage example with Eigen Vector:

   Eigen::VectorXi S =
       vcl::elementSelectionVector<ElemId::VERTEX, Eigen::VectorXi>(myMesh);
   @endif
  
   @note This function does not guarantee that the rows of the vector
   correspond to the element indices of the mesh. This scenario is possible
   when the mesh has deleted elements. To be sure to have a direct
   correspondence, compact the element container before calling this function.
  
   @tparam ELEM_ID: the ID of the element.
   @tparam Vect: type of the vector to be returned.
   @tparam MeshType: type of the input mesh, it must satisfy the MeshConcept.
  
   @param[in] mesh: input mesh
   @return \#E vector of booleans or integers (element selection)
  
   @ingroup export_matrix
  /
template<uint ELEM_ID, typename Vect, MeshConcept MeshType>
Vect elementSelectionVector(const MeshType& mesh)
{
    Vect sV(mesh.template number<ELEM_ID>());
 
    vcl::elementSelectionToBuffer<ELEM_ID>(mesh, sV.data());
    return sV;
}
 

Exceptions

vcl::MissingComponentException if the mesh does not have per-element normals available.

Note: This function does not guarantee that the rows of the matrix correspond to the element indices of the mesh. This scenario is possible when the mesh has deleted elements. To be sure to have a direct correspondence, compact the element container before calling this function.

Template Parameters

ELEM_ID the ID of the element.

Parameters

[in] mesh input mesh

Returns: #E*3 matrix of scalars (element normals)

◆ elementQualityVector()

template<uint ELEM_ID, typename Vect , MeshConcept MeshType>

Vect vcl::elementQualityVector ( const MeshType & mesh )

Get a #E Vector of scalars containing the quality of the elements identified by ELEM_ID of a Mesh. The function is templated on the Vector itself.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-element quality.

Usage example with Eigen Vector:

Eigen::VectorXd EQ =

vcl::elementQualityVector<ElemId::VERTEX, Eigen::VectorXd>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-element quality available.

Note: This function does not guarantee that the rows of the vector correspond to the element indices of the mesh. This scenario is possible when the mesh has deleted elements. To be sure to have a direct correspondence, compact the element container before calling this function.

Template Parameters

ELEM_ID the ID of the element.

Parameters

[in] mesh input mesh

Returns: #E vector of scalars (element quality)

◆ faceColorsMatrix()

template<MatrixConcept Matrix, FaceMeshConcept MeshType>

Matrix vcl::faceColorsMatrix ( const MeshType & mesh )

Get a #F*4 Matrix of integers containing the colors of the faces of a Mesh. The function is templated on the Matrix itself.

This function works with every Matrix type that satisfies the MatrixConcept, and requires that the mesh has per-face colors.

Usage example with Eigen Matrix:

Eigen::MatrixX4i FC = vcl::faceColorsMatrix<Eigen::MatrixX4i>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-face colors available.

Note: This function does not guarantee that the rows of the matrix correspond to the face indices of the mesh. This scenario is possible when the mesh has deleted faces. To be sure to have a direct correspondence, compact the face container before calling this function.

Parameters

[in] mesh input mesh

Returns: #F*4 matrix of integers (face colors)

◆ faceColorsVector()

template<typename Vect , MeshConcept MeshType>

Vect vcl::faceColorsVector	(	const MeshType &	mesh,
		Color::Format	colorFormat
	)

Get a #F Vector of integers containing the colors of the faces of a Mesh. The function is templated on the Vector itself. The color is packed in a single 32 bit value using the provided format.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-face colors.

Usage example with Eigen Vector:

Eigen::VectorXi FC =
    vcl::faceColorsVector<Eigen::VectorXi>(
        myMesh, Color::Format::RGBA);

Exceptions

vcl::MissingComponentException if the mesh does not have per-face colors available.

Note: This function does not guarantee that the rows of the vector correspond to the face indices of the mesh. This scenario is possible when the mesh has deleted faces. To be sure to have a direct correspondence, compact the face container before calling this function.

Parameters

[in] mesh input mesh

Returns: #F vector of integers (face colors)

◆ faceMaterialIndicesVector()

template<typename Vect , FaceMeshConcept MeshType>

Vect vcl::faceMaterialIndicesVector ( const MeshType & mesh )

Get a #F vector of scalars containing the material indices of the faces of a Mesh. The function is templated on the Vector itself.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-face material indices.

Usage example with Eigen Vector:

Eigen::VectorXd VTI =

vcl::faceWedgeMaterialIndicesVector<Eigen::VectorXd>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-face material indices available.

Note: This function does not guarantee that the rows of the vector correspond to the face indices of the mesh. This scenario is possible when the mesh has deleted faces. To be sure to have a direct correspondence, compact the vertex container before calling this function.

Parameters

[in] mesh input mesh

Returns: #F vector of scalars (face material indices)

◆ faceNormalsMatrix()

template<MatrixConcept Matrix, FaceMeshConcept MeshType>

Matrix vcl::faceNormalsMatrix ( const MeshType & mesh )

Get a #F*3 Matrix of scalars containing the normals of the faces of a Mesh. The function is templated on the Matrix itself.

This function works with every Matrix type that satisfies the MatrixConcept, and requires that the mesh has per-face normals.

Usage example with Eigen Matrix:

Eigen::MatrixX3d FN = vcl::faceNormalsMatrix<Eigen::MatrixX3d>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-face normals available.

Note: This function does not guarantee that the rows of the matrix correspond to the face indices of the mesh. This scenario is possible when the mesh has deleted faces. To be sure to have a direct correspondence, compact the face container before calling this function.

Parameters

[in] mesh input mesh

Returns: #F*3 matrix of scalars (face normals)

◆ faceQualityVector()

template<typename Vect , FaceMeshConcept MeshType>

Vect vcl::faceQualityVector ( const MeshType & mesh )

Get a #F Vector of scalars containing the quality of the faces of a Mesh. The function is templated on the Vector itself.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-face quality.

Usage example with Eigen Vector:

Eigen::VectorXd FQ = vcl::faceQualityVector<Eigen::VectorXd>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-face quality available.

Note: This function does not guarantee that the rows of the vector correspond to the face indices of the mesh. This scenario is possible when the mesh has deleted faces. To be sure to have a direct correspondence, compact the face container before calling this function.

Parameters

[in] mesh input mesh

Returns: #F vector of scalars (face quality)

◆ faceVertexIndicesVector()

template<typename Vect , FaceMeshConcept MeshType>

Vect vcl::faceVertexIndicesVector ( const MeshType & mesh )

Get a #V*3 Matrix of scalars containing the positions of the vertices of a Mesh. The function is templated on the Matrix itself.

This function works with every Matrix type that satisfies the MatrixConcept.

Usage example with an Eigen Matrix:

   Eigen::MatrixX3d V = vcl::vertexPositionsMatrix<Eigen::MatrixX3d>(myMesh);
   @endif
  
   @note This function does not guarantee that the rows of the matrix
   correspond to the vertex indices of the mesh. This scenario is possible
   when the mesh has deleted vertices. To be sure to have a direct
   correspondence, compact the vertex container before calling this function.
  
   @tparam Matrix: type of the matrix to be returned, it must satisfy the
   MatrixConcept.
   @tparam MeshType: type of the input mesh, it must satisfy the MeshConcept.
  
   @param[in] mesh: input mesh
   @return \#V*3 matrix of scalars (vertex positions)
  
   @ingroup export_matrix
  /
template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix vertexPositionsMatrix(const MeshType& mesh)
{
    Matrix vM(mesh.vertexNumber(), 3);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    vertexPositionsToBuffer(mesh, vM.data(), stg);
 
    return vM;
}
 

Parameters

[in] mesh input mesh

Returns: #(sum of face sizes) vector of vertex indices

◆ faceWedgeTexCoordsMatrix()

template<MatrixConcept Matrix, FaceMeshConcept MeshType>

Matrix vcl::faceWedgeTexCoordsMatrix ( const MeshType & mesh )

Get a #F*(LFS*2) Matrix of scalars containing the wedge texcoords of the faces of a Mesh. The function is templated on the Matrix itself. LFS is the largest face size of the mesh (this number is variable only for polygonal meshes).

This function works with every Matrix type that satisfies the MatrixConcept, and requires that the mesh has per-face wedge texcoords.

Usage example with Eigen Matrix:

Eigen::MatrixXd FWT = vcl::faceWedgeTexCoordsMatrix<Eigen::MatrixXd>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-face wedge texcoords available.

Note: This function does not guarantee that the rows of the matrix correspond to the face indices of the mesh. This scenario is possible when the mesh has deleted faces. To be sure to have a direct correspondence, compact the vertex container before calling this function.

Parameters

[in] mesh input mesh

Returns: #F*(LFS*2) matrix of scalars (face wedge texcoords)

◆ vertexColorsMatrix()

template<MatrixConcept Matrix, MeshConcept MeshType>

Matrix vcl::vertexColorsMatrix ( const MeshType & mesh )

Get a #V*4 Matrix of integers containing the colors of the vertices of a Mesh. The function is templated on the Matrix itself.

This function works with every Matrix type that satisfies the MatrixConcept, and requires that the mesh has per-vertex colors.

Usage example with Eigen Matrix:

Eigen::MatrixX4i VC = vcl::vertexColorsMatrix<Eigen::MatrixX4i>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-vertex colors available.

Note: This function does not guarantee that the rows of the matrix correspond to the vertex indices of the mesh. This scenario is possible when the mesh has deleted vertices. To be sure to have a direct correspondence, compact the vertex container before calling this function.

Parameters

[in] mesh input mesh

Returns: #V*4 matrix of integers (vertex colors)

◆ vertexColorsVector()

template<typename Vect , MeshConcept MeshType>

Vect vcl::vertexColorsVector	(	const MeshType &	mesh,
		Color::Format	colorFormat
	)

Get a #V Vector of integers containing the colors of the vertices of a Mesh. The function is templated on the Vector itself. The color is packed in a single 32 bit value using the provided format.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-vertex colors.

Usage example with Eigen Vector:

Eigen::VectorXi VC =
    vcl::vertexColorsVector<Eigen::VectorXi>(
        myMesh, Color::Format::RGBA);

Exceptions

vcl::MissingComponentException if the mesh does not have per-vertex colors available.

Note: This function does not guarantee that the rows of the vector correspond to the vertex indices of the mesh. This scenario is possible when the mesh has deleted vertices. To be sure to have a direct correspondence, compact the vertex container before calling this function.

Parameters

[in] mesh input mesh

Returns: #V vector of integers (vertex colors)

◆ vertexMaterialIndicesVector()

template<typename Vect , MeshConcept MeshType>

Vect vcl::vertexMaterialIndicesVector ( const MeshType & mesh )

Get a #V vector of scalars containing the material indices of the vertices of a Mesh. The function is templated on the Vector itself.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-vertex material indices.

Usage example with Eigen Vector:

Eigen::VectorXd VTI =

vcl::vertexMaterialIndicesVector<Eigen::VectorXd>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-vertex material indices available.

Note: This function does not guarantee that the rows of the vector correspond to the vertex indices of the mesh. This scenario is possible when the mesh has deleted vertices. To be sure to have a direct correspondence, compact the vertex container before calling this function.

Parameters

[in] mesh input mesh

Returns: #V vector of scalars (vertex material indices)

◆ vertexNormalsMatrix()

template<MatrixConcept Matrix, MeshConcept MeshType>

Matrix vcl::vertexNormalsMatrix ( const MeshType & mesh )

Get a #V*3 Matrix of scalars containing the normals of the vertices of a Mesh. The function is templated on the Matrix itself.

This function works with every Matrix type that satisfies the MatrixConcept, and requires that the mesh has per-vertex normals.

Usage example with Eigen Matrix:

Eigen::MatrixX3d VN = vcl::vertexNormalsMatrix<Eigen::MatrixX3d>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-vertex normals available.

Note: This function does not guarantee that the rows of the matrix correspond to the vertex indices of the mesh. This scenario is possible when the mesh has deleted vertices. To be sure to have a direct correspondence, compact the vertex container before calling this function.

Parameters

[in] mesh input mesh

Returns: #V*3 matrix of scalars (vertex normals)

◆ vertexQualityVector()

template<typename Vect , MeshConcept MeshType>

Vect vcl::vertexQualityVector ( const MeshType & mesh )

Get a #V Vector of scalars containing the quality of the vertices of a Mesh. The function is templated on the Vector itself.

This function works with every Vector type that has a constructor with a size_t argument and an operator[uint], and requires that the mesh has per-vertex quality.

Usage example with Eigen Vector:

Eigen::VectorXd VQ = vcl::vertexQualityVector<Eigen::VectorXd>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-vertex quality available.

Note: This function does not guarantee that the rows of the vector correspond to the vertex indices of the mesh. This scenario is possible when the mesh has deleted vertices. To be sure to have a direct correspondence, compact the vertex container before calling this function.

Parameters

[in] mesh input mesh

Returns: #V vector of scalars (vertex quality)

◆ vertexTexCoordsMatrix()

template<MatrixConcept Matrix, MeshConcept MeshType>

Matrix vcl::vertexTexCoordsMatrix ( const MeshType & mesh )

Get a #V*2 Matrix of scalars containing the texcoords of the vertices of a Mesh. The function is templated on the Matrix itself.

This function works with every Matrix type that satisfies the MatrixConcept, and requires that the mesh has per-vertex texcoords.

Usage example with Eigen Matrix:

Eigen::MatrixX2d VT = vcl::vertexTexCoordsMatrix<Eigen::MatrixX2d>(myMesh);

Exceptions

vcl::MissingComponentException if the mesh does not have per-vertex texcoords available.

Note: This function does not guarantee that the rows of the matrix correspond to the vertex indices of the mesh. This scenario is possible when the mesh has deleted vertices. To be sure to have a direct correspondence, compact the vertex container before calling this function.

Parameters

[in] mesh input mesh

Returns: #V*2 matrix of scalars (vertex texcoords)

Functions

Detailed Description

Function Documentation

◆ edgeColorsMatrix()

◆ edgeColorsVector()

◆ edgeQualityVector()

◆ edgeVertexIndicesMatrix()

◆ elementColorsMatrix()

◆ elementColorsVector()

◆ elementNormalsMatrix()

◆ elementQualityVector()

◆ faceColorsMatrix()

◆ faceColorsVector()

◆ faceMaterialIndicesVector()

◆ faceNormalsMatrix()

◆ faceQualityVector()

◆ faceVertexIndicesVector()

◆ faceWedgeTexCoordsMatrix()

◆ vertexColorsMatrix()

◆ vertexColorsVector()

◆ vertexMaterialIndicesVector()

◆ vertexNormalsMatrix()

◆ vertexQualityVector()

◆ vertexTexCoordsMatrix()