 |
PK_TOPOL_render_line_o_t |
|
struct PK_TOPOL_render_line_o_s
{
int o_t_version;--- version of this PK option struct
PK_render_edge_t edge; --- whether to draw edges
--- (PK_render_edge_yes_c)
PK_render_silhouette_t silhouette; --- whether to draw silhouettes
--- (PK_render_silhouette_no_c)
PK_MESH_normal_field_t sil_mesh_normal_field;
--- whether silhouettes on meshes are
--- computed using mvertex normals
--- (PK_MESH_normal_field_mvertex_c)
PK_render_sharp_mfins_t sharp_mfins;--- whether to draw sharp mfins on
--- faces with facet geometry
--- (PK_render_sharp_mfins_no_c)
PK_render_vis_t visibility; --- whether to determine visibility
--- (PK_render_vis_no_c)
PK_render_invisible_t invisible; --- whether to output invisible lines
--- when 'visibility' is set to
--- PK_render_vis_extended_c
--- (PK_render_invisible_no_c)
PK_render_drafting_t drafting; --- whether to distinguish lines
--- hidden by lines and faces
--- when 'visibility' is set to
--- PK_render_vis_extended_c
--- (PK_render_drafting_no_c)
PK_render_self_hidden_t self_hidden;--- whether to distinguish lines
--- hidden by own or another
--- occurrence when 'visibility' is
--- set to PK_render_vis_extended_c
--- (PK_render_self_hidden_no_c)
---------------------------------------------------------------------------
PK_LOGICAL_t is_curve_chord_tol;
--- whether curve_chord_tol is set
--- ( PK_LOGICAL_false )
double curve_chord_tol;
--- chordal tolerance between curve
--- and chord edges in model units
--- ( 0.0 )
PK_LOGICAL_t is_curve_chord_max;
--- whether curve_chord_max is set
--- ( PK_LOGICAL_false )
double curve_chord_max;
--- max length of chord in model units
--- ( 0.0 )
PK_LOGICAL_t is_curve_chord_ang;
--- whether curve_chord_ang is set
--- ( PK_LOGICAL_false )
double curve_chord_ang;
--- max angle between adjacent chords
--- in radians
--- ( 0.0 )
---------------------------------------------------------------------------
PK_render_smooth_t smooth; --- whether to indicate smooth edges
--- (i.e. where faces have the same
--- tangent surface at the edge)
--- (PK_render_smooth_no_c)
PK_LOGICAL_t is_edge_smooth_tol;
--- whether edge_smooth_tol is set
--- ( PK_LOGICAL_false )
double edge_smooth_tol;
--- max angle (in radians) allowed
--- between face
--- normals for edge to be smooth
--- ( 0.0 )
PK_render_internal_t internal; --- whether to indicate internal edges
--- (i.e. where faces on either side
--- of the edge lie on same surface)
--- (PK_render_internal_no_c)
PK_render_ske_missing_t ske_missing; --- whether to draw bodies with
--- missing geometry
--- (PK_render_ske_missing_no_c)
PK_render_ignore_t ignore;
--- whether to ignore small features
--- in hidden line rendering.
--- Small features can be ignored
--- by inputting an absolute value or
--- a ratio value
--- ( PK_render_ignore_no_c )
double ignore_value;
--- features smaller than this value
--- will be considered for ignoring
--- ( 0.0 )
---------------------------------------------------------------------------
PK_render_hierarch_t hierarch; --- whether to produce hierarchical
--- output (PK_render_hierarch_no_c)
PK_render_bcurve_t bcurve; --- method for rendering bcurves
--- (PK_render_bcurve_polyline_c)
PK_render_memory_target_t memory_target;
--- whether to restrict memory usage
--- ( PK_render_memory_target_no_c )
size_t memory_target_value;
--- target memory usage in bytes
--- ( 0 )
PK_render_report_line_t report_lines; --- whether to report line fit
--- failures and refits
--- (PK_render_report_line_no_c)
---------------------------------------------------------------------------
PK_render_planar_t planar; --- whether to draw planar hatching
--- (PK_render_planar_no_c)
double planar_spacing;
--- distance between planes for
--- planar hatching
--- ( 0.0 )
PK_AXIS1_sf_t planar_axis;
--- axis for planar hatching
--- (location 0,0,0 direction 0,0,0)
PK_render_radial_t radial; --- whether to draw radial hatching
--- (PK_render_radial_no_c)
double radial_around;
--- angular spacing around spine for
--- radial hatching
--- ( 0.0 )
double radial_along;
--- spacing in model units along spine
--- ( 0.0 )
double radial_about;
--- angular spacing about centre
--- ( 0.0 )
double radial_around_start;
--- starting value for angular
--- spacing around
--- spine for radial hatching
--- ( PK_TOPOL_render_value_null )
double radial_along_start;
--- starting value for spacing in
--- model units along spine
--- ( PK_TOPOL_render_value_null )
double radial_about_start;
--- starting value for angular
--- spacing about centre
--- ( PK_TOPOL_render_value_null )
PK_render_param_t param; --- whether to draw parametric hatch
--- (PK_render_param_no_c)
double param_u;
--- hatch spacing in u direction
--- ( 0.0 )
double param_v;
--- hatch spacing in v direction
--- ( 0.0 )
int param_u_number;
--- number of u direction hatch lines.
--- Used only when 'param' set to
--- PK_render_param_number_free_c
--- ( 0 )
int param_v_number;
--- number of v direction hatch lines.
--- Used only when 'param' set to
--- PK_render_param_number_free_c
--- ( 0 )
double param_u_start;
--- starting value for hatch spacing
--- in u direction
--- ( PK_TOPOL_render_value_null )
double param_v_start;
--- starting value for hatch spacing
--- in v direction
--- ( PK_TOPOL_render_value_null )
PK_render_unfix_t unfix; --- whether to draw unfixed blends
--- (PK_render_unfix_no_c) [NF]
double unfix_spacing;
--- unfixed blend default rib spacing
--- ( 0.0 ) [NF]
---------------------------------------------------------------------------
PK_render_overlap_t overlap;
--- whether to allow for overlapping
--- bodies
--- ( PK_render_overlap_no_c )
int n_overlap_indices;
--- number of body occurrences in
--- 'overlap_indices1' (0)
const int *overlap_indices1;
--- first array of body occurrences to
--- to be clashed (NULL)
int n_overlap_indices2;
--- number of body occurrences in
--- 'overlap_indices2' (0)
const int *overlap_indices2;
--- second array of body occurrences
--- to be clashed (NULL)
PK_render_transparent_t transparent; --- whether to draw transparent bodies
--- (PK_render_transparent_no_c)
int n_transparent_indices;
--- number of transparent indices (0)
const int *transparent_indices;
--- array of body occurrences to be
--- rendered transparent (NULL)
PK_render_transp_hid_t transparent_hid;
--- whether to allow transparent
--- bodies to appear opaque and
--- obscure other transparent bodies
--- (PK_render_transp_hid_no_c)
int n_suppressed_indices;
--- number of body occurrences in
--- 'suppressed_indices' (0)
const int *suppressed_indices;
--- array of body occurrences for
--- which invisible lines are to be
--- suppressed (NULL)
PK_render_viewport_t viewport; --- whether to use viewport(s)
--- (PK_render_viewport_no_c)
PK_render_viewport_type_t viewport_type;
--- type of viewport
--- (PK_render_viewport_type_3D_c)
int n_viewports;
--- number of viewports (0)
const PK_NABOX_sf_t *viewports;
--- array of viewports (NULL)
PK_NABOX_sf_t viewport_sf;
--- viewport definition
--- if single viewport is used, i.e.
--- PK_render_viewport_yes_c chosen
--- ( (location 0,0,0 axis 0,0,0
--- direction 0,0,0)
--- (0.0, 0.0, 0.0, 0.0, 0.0, 0.0) )
PK_render_viewport_clip_t viewport_clipping;
--- use viewport clipping
--- (PK_render_viewport_clip_no_c)
PK_render_region_t region; --- whether to produce regional data
--- (PK_render_region_no_c)
};
typedef struct PK_TOPOL_render_line_o_s PK_TOPOL_render_line_o_t;
Controls for the PK_TOPOL_render_line options structure
Used in:
PK_TOPOL_render_line
PK_TOPOL_render_line_o_t provides controls for PK_TOPOL_render_line to
generate view-independent, view-dependent and hidden line drawings of
topological entities through the Graphics Output (GO) interface.
See option settings for more information in addition to that
provided below.
The controls allow view independent and view dependent data (silhouettes)
to be generated in the same call to PK_TOPOL_render_line. Hidden line
drawings should be generated in a separate call to PK_TOPOL_render_line
because their arguments are generally incompatible with those used for
the other categories of drawing.
The options specify which types of lines should be rendered (e.g. edges,
silhouettes, sharp mfins) and what additional data (e.g. visibility and
smoothness) needs to be calculated and handed onto GO.
Mesh Silhouette Method
If 'sil_mesh_normal_field' is set to PK_MESH_normal_field_mvertex_c, mesh
vertex normals will be used to generate silhouette curves on meshes. If set to
PK_MESH_normal_field_mfacet_c, mfacet normals will be used. This option is
ignored on classic geometry.
Sharp Mfins
The 'sharp_mfins' options controls whether to output sharp mfins on meshes. The
criteria for sharpness are as defined by PK_MFIN_is_sharp.
The 'sharp_mfins' option can be set to one of the following values:
PK_render_sharp_mfins_yes_c: On each face with facet geometry, Parasolid will
output polylines running along chains of connected
sharp mfins. The chains will be divided at any
mvertex that has more than two sharp mfins
pointing into it.
Where an edge is coincident with a chain of sharp
mfins, only the edge will be output. In
hidden-line drawings Parasolid will indicate that
the edge segment is coincident with sharp mfins.
Where a sharp mfin polyline lies along a
silhouette, only the sharp mfin polyline will be
output. In hidden-line drawings Parasolid will
indicate that the sharp-mfin segment is coincident
with a silhouette.
PK_render_sharp_mfins_no_c : Parasolid will not output sharp mfins.
Visibility
If 'visibility' is set to PK_render_vis_no_c then no visibility evaluation
(ie hidden line drawing) is performed. Common visibility requirements may
be requested by the values: PK_render_vis_hid_c, PK_render_vis_inv_c and
PK_render_vis_inv_draft_c. For more refined control over visibility
requirements, 'visibility' may be set to PK_render_vis_extended_c which
then enables the options: 'invisible', 'drafting' and 'self_hidden'.
In the cases of specifying that invisible lines are to be output, an
optional list of body indices into the 'topols' array may be specified
to suppress the display of hidden lines only for those bodies.
This is done by supplying the auxilliary data 'n_suppressed_indices' and
'suppressed_indices' to indicate the number of bodies and the body indices
respectively. Any hidden lines from these bodies will not be output, and
will not obscure coincident hidden lines on other bodies.
See Visibility for more information.
Tolerance Values
Each control tolerance is passed as a pair of values, consisting of a
PK_LOGICAL_t flag and a double precision value. If a specific tolerance
is required, the variable is set to a strictly positive value and the
associated flag set to PK_LOGICAL_true.
If Parasolid is to use its internal tolerance defaults, the associated flag is
set to PK_LOGICAL_false (and no use made of the associated tolerance argument).
This is the default state set by the PK_TOPOL_render_line_o_m macro.
A report is returned via the Parasolid report mechanism of type
PK_REPORT_record_type_3_c. This record will have a 'status' of
PK_REPORT_3_render_curve_tols_c and contain the three tolerance values used by
Parasolid, whether supplied or calculated internally.
See Display Tolerances for more information.
Edge Smoothness
If 'is_edge_smooth_tol' is set to true, the value in 'edge_smooth_tol'
defines the angular tolerance (in radians) for the smoothness property
in the same way as PK_EDGE_is_smooth.
The criteria for smoothness is defined as being that the angle between the
normals of the two faces that meet at a given edge do not exceed the angle
supplied in 'edge_smooth_tol'.
If 'is_edge_smooth_tol' is set to false, the angular tolerance used will
depend upon the accuracy of the relevant edge.
See Tolerance on smooth edges for more information.
Sketching Bodies with Missing Geometry
PK_render_ske_missing_t controls the sketching of bodies containing entities
that have missing geometry.
PK_render_ske_missing_no_c: returns PK_ERROR_missing_geom when encountering
missing geometry.
PK_render_ske_missing_yes_c: ignores entities with missing geom and continues
to sketch all other entities. Any edges with missing geometry will be omitted.
Any faces with missing surface geometry or missing edge geometry will omit
silhouettes or hatched lines, if these have also been requested.
PK_render_ske_missing_yes_c is only available when view dependent or view
independent wire-frame rendering has been requested. It is not compatible with
visibility calculations.
Ignore Small Features
The 'ignore' option can be set to one of the following values:
PK_render_ignore_no_c: (default) All features will be rendered regardless of
their size.
PK_render_ignore_absolute_c: Any feature with a box size smaller than the
value specified will be ignored.
PK_render_ignore_ratio_c: The 'ignore_value' corresponds to the ratio of box
size of the feature to the size of the box containing the entities to be
rendered i.e. if this value is set to 0.01 then all features smaller than 1
per-cent of the entities' box will be ignored.
PK_render_ignore_body_ratio_c: The 'ignore_value' corresponds to the ratio of
the box size of the feature to the size of the box of the body containing the
feature.
This option only takes effect when visibility is not set to
PK_render_vis_no_c. Note that 'small' features will only be ignored provided
that ignoring them does not leave the model invalid.
See Ignoring small features for more information.
Memory Target
The 'memory_target' option can be set to one of the following values:
PK_render_memory_target_yes_c: Parasolid will attempt to restrict the memory
usage of PK_TOPOL_render_line to the amount of memory given by
"memory_target_value". The target value is not guaranteed to be met. The
amount of memory used by PK_TOPOL_render_line will be reduced at the expense
of total processor time.
The value given by 'memory_target' refers to the peak amount of extra memory
temporarily allocated during PK_TOPOL_render_line.
PK_render_memory_target_no_c: Parasolid will maximise performance without
attempting to restrict memory usage.
This option only takes effect when visibility is not set to
PK_render_vis_no_c.
See Controlling memory usage for more information.
Line fit report
If 'report_lines' is set to anything but 'PK_render_report_line_no_c', then a
report is returned via the Parasolid report mechanism of type
PK_REPORT_record_type_3_c. This record will have a 'status' of
PK_REPORT_3_line_fit_tols_c and return information for curves that could not
be fitted with a linear approximation both in the event that it could not be
fitted at all and if it was refitted by altering the prescribed chord and
angular tolerances. The curve type, associated edge or face tags, and changed
tolerance values are included in the report for each failed curve fit or
successful refit using altered tolerances.
Radial and Param Default Start Values
If no values are specified for the radial start values then the option
PK_render_radial_yes_c will behave like PK_render_radial_free_c and
Parasolid will choose the start values. Similarly, if no param start
values are specified then the option PK_render_param_spaced_c will behave
like PK_render_param_spaced_free_c and Parasolid will choose the start values.
See Hatching for more information.
Overlapping Body Occurrences
By default, Parasolid assumes that rendered instances after they have been
transformed do not overlap. So if you need intersection lines to be generated
then you must set the 'overlap' option to specify the required output. You
must use this option if, for example, you require rendering of intersection
lines for an assembly containing clashing instances, i.e. instances that share
a common volume. This option can be set to one of the following values:
PK_render_overlap_no_c: Parasolid assumes that the body occurrences to be
rendered do not overlap. If there are overlapping occurrences present then the
overlap will not be detected and the resulting picture may contain errors.
PK_render_overlap_yes_c: Parasolid will detect overlapping body occurences
and will split the existing lines appropriately. However, the algorithm will
not generate new edges where the faces interfere with each other. The
additional effort of detecting overlaps will incur a performance overhead
compared to PK_render_overlap_no_c.
PK_render_overlap_intsec_all_c: This option is similar to
PK_render_overlap_yes_c but it will also generate and render any interference
curves between body occurrences that overlap. Two arrays of indices into the
'topols' array can be used to limit or "filter" the set of occurrences that are
actually clashed. The fields 'n_overlap_indices' and 'n_overlap_indices2'
should be set to the number of occurrences in 'overlap_indices1' and
'overlap_indices2' respectively. The arrays can be of any size and each body
occurrence in the first array will be clashed with each body occurence in
the second array as long as both arrays contain at least one body occurrence.
If one of the arrays is empty (either 'n_overlap_indices' is 0 or
'n_overlap_indices2' is 0) then all of the body occurrences in the non-empty
array will be clashed with one another. If 'n_overlap_indices' and
'n_overlap_indices2' are both are 0 then all occurrences in the 'topols' array
will be clashed with one another. The additional effort of detecting overlaps
and interference curves will incur a further performance overhead compared to
PK_render_overlap_yes_c.
PK_render_overlap_intsec_pair_c: This option is similar to
PK_render_intsec_all_c in that it can generate and render interference
curves between body occurrences that overlap. It requires that both arrays
'overlap_indices1' and 'overlap_indices2' are entered and that both have the
same non-zero length ('n_overlap_indices' must equal 'n_overlap_indices2').
Interference curves will be generated for pairs of body occurrences made up of
corresponding entries in the two arrays. The additional effort of detecting
overlaps and interference curves will incur a further performance overhead
compared to PK_render_overlap_yes_c.
PK_render_overlap_intersect_c: (deprecated) Parasolid will detect overlapping
body occurrences and will split the existing lines appropriately. However, the
algorithm will generate additional new interference curves where the
occurrences intersect. The additional effort of detecting overlaps and
interference curves will incur a further performance overhead over that for
PK_render_overlap_yes_c.
If this option is selected, and if the lists are of equal non-zero length,
the behaviour is the same as if the PK_render_overlap_intsec_pair_c option had
been used; otherwise the behaviour is as for PK_render_overlap_intsec_all_c.
These options only take effect when visibility is not set to
PK_render_vis_no_c. Abutting body occurrences will always be rendered
correctly, regardless of the setting of the option.
See Overlapping for more information.
Transparency
There are two methods for rendering transparent bodies:
1 - Attach a transparency system attribute SDL/TYSA_TRANSPARENCY
(with transparency coefficient of value greater or equal to 1) to all bodies
that are to be rendered transparent, and set the 'transparent' option to
PK_render_transparent_yes_c.
2 - Set the 'transparent' option to PK_render_transparent_index_c, and then
specify the index value of the bodies (according to the order that they appear
in the array topols[]) that are to be rendered transparent within the array
'transparent_indices'. The value 'n_transparent_indices' is the length of this
array. Thus if the body occurrences to be rendered transparent lie in the
third and fifth position of the array topols, then 'transparent_indices' will
be {2, 4}, and 'n_transparent_indices' will have value 2. This option can be
used to make some occurrences of the same body appear transparent, without the
need to use a transparency attribute.
The 'transparent_hid' option can be used to control the rendering of
transparent bodies within hidden line rendering. Setting the 'transparent_hid'
option to PK_render_transp_hid_no_c will render transparent bodies as in the
methods mentioned above. If 'transparent_hid' is set to
PK_render_transp_hid_yes_c, then all transparent bodies will be rendered
opaque, but they will only obscure other transparent body occurrences.
For more information, see Transparency in the Functional Descripion.
Multiple Viewports
PK_render_viewport_t controls the multiple viewport behaviour.
PK_render_viewport_no_c: no viewports are supplied. (default)
PK_render_viewport_yes_c: the single viewport specified in 'viewport_sf'
is used. Entities outside the single supplied viewport may be omitted. In this
case, 'n_viewports' and 'viewports' are ignored.
PK_render_viewport_array_c: an array of viewports is supplied. Entities
outside all the supplied viewports may be omitted. 'viewport_sf' is
ignored. The number of viewports used is set in 'n_viewports' and can be set
to zero or a positive integer. The array of viewports is specified in
'viewports'.
PK_render_viewport_type_t controls the type of viewport being used for this
rendering. Although multiple viewports can be specified, they all must be of
the same type.
PK_render_viewport_type_3D_c: allows for a general non-aligned box to be used
to specify a region of a set of bodies to be rendered. (default)
PK_render_viewport_type_2D_c: is used to indicate a 2D viewport. In a 2D
viewport, the 'axis' specified in the viewport's 'basis_set' (PK_AXIS2_sf_t)
must be the same as the view direction ('view_transf') specified in the call to
PK_TOPOL_render_line. If this is not the case for each viewport, then an error
of type PK_ERROR_bad_2d_viewport will be returned.
See Viewport for more information.
Viewport Clipping
PK_render_viewport_clip_yes_c: This is used to enable clipping to the given
type of viewport.
PK_render_viewport_clip_no_c: This is used to indicate that although the
viewport option has been turned on and viewports provided, no clipping will
occur. (default)