Performing Evaluations On Meshes

Contents

• 88.1 Introduction
• 88.2 Differences between mesh parameterisation and surface parameterisation
  • 88.2.1 Evaluating mesh parameters
• 88.3 Mesh normals
  • 88.3.1 Evaluating normals on a mesh
  • 88.3.2 Managing mvertex normals
    • 88.3.2.1 Enquiring the properties of normals in a mesh
    • 88.3.2.2 Using the mesh angle to control the “smoothness” of a mesh
    • 88.3.2.3 Finding sharp mvertices in meshes
    • 88.3.2.4 Finding sharp mfins in meshes
    • 88.3.2.5 Storing and discarding normals
• 88.4 Finding perimeters of mfacets
  • 88.4.1 Including wire mfins in the perimeter of a set of mfacets
• 88.5 Finding the mtopology along a fin

[back to top]

88.1 Introduction

There are fundamental differences between meshes and classic B-rep surfaces which mean that the evaluation of surface parameters and normals need to be treated differently in order to produce consistent and accurate results. This chapter explains those differences and describes the APIs you should use to manage them.

When used in traditional modelling, classic B-rep surfaces are generally smooth entities. While they can contain discontinuities, a surface that contains a G1-discontinuity cannot be attached to topology. G1-discontinuities in a classic B-rep surface always occur along constant parameter lines, and you can use PK_SURF_eval_handed, PK_SURF_eval_curvature_handed, and PK_SURF_eval_with_normal_handed to distinguish which side of a discontinuity you want to evaluate.

By contrast, meshes are inherently G1-discontinuous entities, with a line of (C0) discontinuity across every mfin, and every point on an mfin has multiple parameterisations. Meshes, of course, can be attached to topology.

[back to top]

88.2 Differences between mesh parameterisation and surface parameterisation

For the most part, Parasolid allows you to evaluate a mesh in much the same way as you evaluate a classic B-rep surface, using one of several PK_SURF_eval_... functions. You can find your position inside a mesh using the same functions you would use to find your position in a classic B-rep surface.

However, because there are no restrictions on the shape represented by a mesh, parameterisation of a mesh needs to be a discrete process that considers each facet individually, and this means that you cannot use Parasolid's surface evaluation functionality to march or step across a mesh.

Within each mfacet, Parasolid uses a linear mapping of a barycentric parameterisation . There is one mfin that is constant in U, one that is constant in V, and one that isn’t a constant in either U or V. Parasolid does not guarantee which mfin is which. This means that there is no clear U/V or left/right distinction for meshes, and so the Parasolid's “handed” evaluation functions cannot be supported for meshes.

These fundamental properties of meshes give rise to the following differences, compared to classic B-rep surfaces, when evaluating on meshes:

• Derivative information is not calculated for meshes.
• UV-boxes are not calculated for meshes.
• If you call PK_SURF_eval_with_normal or PK_SURF_eval_curvature at parameters on an mfin or an mvertex, the value returned is the average of the individual normals or curvatures at that position. If you want to calculate individual normals or curvatures at a given mvertex you can call PK_MFIN_ask_mvx_normal or PK_MFIN_ask_mvx_curvature on the appropriate mfin of the mvertex.
• The PK_SURF_eval..._handed functions are not supported for meshes
• When creating a facet body from a classic B-rep body using PK_BODY_make_facet_body, the mesh does not inherit the parameterisation of the classic body.

88.2.1 Evaluating mesh parameters

Parasolid provides a number of functions for evaluating mesh parameters.These are as follows:

[back to top]

88.3 Mesh normals

Like any other type of surface, any point on a mesh has an associated normal. Broadly speaking, there are two different types of normal that you can evaluate on a mesh:

88.3.1 Evaluating normals on a mesh

Parasolid provides a number of functions for evaluating normals on a mesh:

88.3.2 Managing mvertex normals

Parasolid offers a variety of methods for managing mvertex normals on a mesh: You can either:

• Ask Parasolid to calculate mvertex normals dynamically when enquiring mesh data
• Store normal data for all mvertices in the mesh.

In addition, if you choose to store normal data, you can either:

• Store a single normal at each mvertex, thereby treating the mfacets that surround it as essentially smooth
• Store multiple normals at each mvertex, thereby allowing you to identify creases in the mesh along connected mfins.

This section describes the APIs Parasolid offers for managing normal data.

88.3.2.1 Enquiring the properties of normals in a mesh

Parasolid provides functionality to let you enquire about the types of normal data available to a mesh.

• PK_MESH_ask_normal_type tells you whether a mesh has stored normals, or whether they are calculated dynamically.
• PK_MESH_has_unique_normals tells you whether a given mesh has unique normals. It can be called on any mesh, whether it has stored normals or whether the normals are calculated dynamically. A mesh has unique normals if for every mvertex in the mesh, all the mfins at that mvertex share the same normal as returned by PK_MFIN_ask_mvx_normal. If any of the mvertices in the mesh have multiple normals, PK_MESH_has_unique_normals will return PK_LOGICAL_false.

88.3.2.2 Using the mesh angle to control the “smoothness” of a mesh

Parasolid provides a session-wide mesh angle to let you control which parts of a mesh are considered to be smooth. You can set this mesh angle using PK_SESSION_set_mesh_angle, and enquire its current value using PK_SESSION_ask_mesh_angle.

The mesh angle partitions the ordered ring of mfacets around an mvertex into sets of mfacets that are considered to be smoothly connected, based on the angle of the normals between adjacent mfacets.

• If the angle of the normals between adjacent facets is less than the mesh angle, then the boundary between those mfacets is considered smooth. Knowing this information can speed up some downstream operations because they do not need to check if the mfacet is considered smooth.
• If the angle of the normals between adjacent facets is greater than mesh angle then the boundary between those mfacets is not considered smooth, and there is a crease between them. This can be beneficial in shading and rendering operations where it is preferable to use real sharp edges.

For example, two ways in which you might use the mesh angle are as follows:

• If you set the mesh angle to pi (as shown in Figure 88-1), this ensures that there is only a single normal at any mvertex: all fins at the mvertex share this normal and all mfacets appear smooth.
• If you set the mesh angle to 0 (as shown in Figure 88-1), this ensures that there are multiple normals at any mvertex whose adjacent mfacets are not completely smooth to within session tolerance.

Figure 88-1 Examples of using the mesh angle to control the smoothness of the mesh

88.3.2.3 Finding sharp mvertices in meshes

You can find the sharp mvertices in a given mesh using PK_MESH_find_sharp_mvxs. A sharp mvertex is one that does not have a unique normal, i.e the mfins at this mvertex do not share the same normal as returned from PK_MFIN_ask_mvx_normal. See Section 88.3.1, “Evaluating normals on a mesh” for more information on this function.

By default, the want_sharp_mvxs option returns the number of sharp mvertices together with a list of those mvertices. To return just the number of sharp mvertices, set the want_sharp_mvxs option to PK_LOGICAL_false.

88.3.2.4 Finding sharp mfins in meshes

You can find the sharp mfins in a mesh using PK_MESH_find_sharp_mfins. An mfin is considered sharp if it is non-laminar, and if, for the mvertices at either end of the mfin, the two adjacent mfacets do not share a normal as returned by PK_MFACET_ask_mvx_normals. Further control over the comparison of normals is given by the values of have_sharp_angle and sharp_angle. This function takes the following options:

88.3.2.5 Storing and discarding normals

You use PK_MESH_store_normals to store or modify the normals on a mesh, replacing any existing stored data as required. You can choose whether to store normals for the entire mesh, or whether to replace the normals for specific mtopols in the mesh. If replacing specific normals, you can also choose whether to supply the normal data yourself, or whether to let Parasolid calculate it for you.

You do not have to store normal data on a mesh: Parasolid dynamically calculates any normals that are required if no stored data is available. These dynamic normals are stored in the mesh throughout the session and are discarded if the mesh changes.

You can also use the mesh_angle option to override any mesh angle specified for the session.

See PK_MESH_store_normals_o_t for more information.

You can discard any stored normals in a mesh using PK_MESH_discard_normals. Once discarded, normals for that mesh are calculated dynamically by Parasolid until you store new normal data.

[back to top]

88.4 Finding perimeters of mfacets

You can use PK_MFACET_find_perimeters to find the perimeters around a supplied set of mfacets. A perimeter is a set of mfins that form the boundary of a set of mfin-connected mfacets.

Perimeters are returned as a set of one or more mloops. An mloop is a connected set of mfins ordered into a closed loop in the direction of the mfins. Each mloop has to have a minimum of 2 mfins which have to be:

• Attached to an mfacet in the received array
• Laminar or have an adjacent mfin that belongs to another mfacet that is not from the received array.

Perimeters can contain more than one mloop. All mloops belonging to the same perimeter bound the same mfin-connected set of mfacets.

Figure 88-2 shows the perimeters and mloops of supplied subsets of mfacets on a given mesh. In (A) two mfacets (coloured in red) are selected. These are mfin-connected and therefore return 1 perimeter. A single closed mloop is also returned. In (B), the mfacets selected are mvertex-connected not mfin-connected and therefore return two perimeters and two closed mloops.

Figure 88-2 Finding perimeters and mloops on a subset of mfacets on a mesh

Knowing the perimeters and mloops for a subset of mfacets allows you to split complex mesh bodies into multiple mesh faces, making it easier to modify or replace certain parts of the mesh body.

PK_MFACET_find_perimeters takes the following options:

88.4.1 Including wire mfins in the perimeter of a set of mfacets

If the supplied set of mfacets contains internal edges that you want to use in further operations, you can use the select_wire_mfins option to return them by including wire mfins in the perimeter. An mfin that forms part of the perimeter of a set of mfacets is considered to be a wire mfin if both it and its adjacent mfin (i.e the mfin returned from PK_MFIN_ask_mfin_adjacent) lie on the perimeter.

The select_wire_mfins option takes the following values:

Figure 88-3 shows an example where the selected set of mfacets contain sharp mfins. A) shows the perimeter returned when wire mfins are included in the result, and B) shows the perimeter returned when wire mfins are excluded.

Figure 88-3 Including and excluding wire mfins in the perimeter

[back to top]

88.5 Finding the mtopology along a fin

You can find the mvertices and/or mfins along a given fin using PK_FIN_find_mtopols.

The want_mvertices option controls whether to return an array of mvertices along with the number of those mvertices. The want_mfins option controls whether to return an array of mfins along with the number of those mfins. By default, these options are set to PK_LOGICAL_true. To return just the number of mvertices and/or mfins, these options must be set to PK_LOGICAL_false.

Figure 88-4 Finding the mfins and mvertices along a fin

[back to top]