| Integrated generic resource: Geometric and topological representation | ISO 10303-42:2021(E) © ISO |
(*
ISO/TC 184/SC 4/WG 12 N10585 - ISO 10303-42 Geometric and topological representation - EXPRESS
Supersedes
ISO/TC 184/SC 4/WG 12 N10468
*)
SCHEMA geometry_schema;
REFERENCE FROM
geometric_model_schema -- ISO 10303-42
(block,
boolean_result,
cyclide_segment_solid,
eccentric_cone,
edge_based_wireframe_model,
ellipsoid,
face_based_surface_model,
faceted_primitive,
geometric_set,
half_space_solid,
primitive_2d,
rectangular_pyramid,
right_angular_wedge,
right_circular_cone,
right_circular_cylinder,
shell_based_surface_model,
shell_based_wireframe_model,
solid_model,
sphere,
tessellated_item,
torus);
REFERENCE FROM
measure_schema -- ISO 10303-41
(global_unit_assigned_context,
length_measure,
parameter_value,
plane_angle_measure,
plane_angle_unit,
positive_length_measure,
positive_plane_angle_measure);
REFERENCE FROM
representation_schema -- ISO 10303-43
(definitional_representation,
founded_item,
functionally_defined_transformation,
item_in_context,
representation,
representation_context,
representation_item,
using_representations);
REFERENCE FROM
scan_data_3d_shape_model_schema -- ISO 10303-42
(scanned_data_item);
REFERENCE FROM
topology_schema -- ISO 10303-42
(edge_curve,
face_surface,
poly_loop,
vertex_point,
volume_with_faces);
CONSTANT
dummy_gri : geometric_representation_item := representation_item('')|| geometric_representation_item();
END_CONSTANT;
TYPE axis2_placement =
SELECT
(axis2_placement_2d,
axis2_placement_3d);
END_TYPE;
TYPE b_spline_curve_form =
ENUMERATION
OF
(polyline_form,
circular_arc,
elliptic_arc,
parabolic_arc,
hyperbolic_arc,
unspecified);
END_TYPE;
TYPE b_spline_surface_form =
ENUMERATION
OF
(plane_surf,
cylindrical_surf,
conical_surf,
spherical_surf,
toroidal_surf,
surf_of_revolution,
ruled_surf,
generalised_cone,
quadric_surf,
surf_of_linear_extrusion,
unspecified);
END_TYPE;
TYPE curve_on_surface =
SELECT
(composite_curve_on_surface,
pcurve,
surface_curve);
END_TYPE;
TYPE dimension_count =
INTEGER;
WHERE
WR1: SELF > 0;
END_TYPE;
TYPE extent_enumeration =
ENUMERATION
OF
(invalid,
zero,
finite_non_zero,
infinite);
END_TYPE;
TYPE knot_type =
ENUMERATION
OF
(uniform_knots,
quasi_uniform_knots,
piecewise_bezier_knots,
unspecified);
END_TYPE;
TYPE linearly_independent_enum =
ENUMERATION
OF
(independent,
not_independent,
not_tested);
END_TYPE;
TYPE locally_refined_spline_type_enum =
ENUMERATION
OF
(analysis_suitable_t_spline,
hierarchical_b_spline,
lr_b_spline,
semi_standard_t_spline,
standard_t_spline);
END_TYPE;
TYPE pcurve_or_surface =
SELECT
(pcurve,
surface);
END_TYPE;
TYPE preferred_surface_curve_representation =
ENUMERATION
OF
(curve_3d,
pcurve_s1,
pcurve_s2);
END_TYPE;
TYPE spline_knot_values =
LIST[2:?] OF REAL;
WHERE
WR1: increasing_values_in_list(SELF);
END_TYPE;
TYPE surface_boundary =
SELECT
(boundary_curve,
degenerate_pcurve);
END_TYPE;
TYPE transition_code =
ENUMERATION
OF
(discontinuous,
continuous,
cont_same_gradient,
cont_same_gradient_same_curvature);
END_TYPE;
TYPE trimming_preference =
ENUMERATION
OF
(cartesian,
parameter,
unspecified);
END_TYPE;
TYPE trimming_select =
SELECT
(cartesian_point,
parameter_value);
END_TYPE;
TYPE vector_or_direction =
SELECT
(direction,
vector);
END_TYPE;
ENTITY geometric_representation_context
SUBTYPE OF (representation_context);
coordinate_space_dimension : dimension_count;
END_ENTITY;
ENTITY geometric_representation_item
SUPERTYPE OF
(ONEOF (point,
direction,
vector,
placement,
cartesian_transformation_operator,
curve,
surface,
edge_curve,
face_surface,
poly_loop,
vertex_point,
solid_model,
boolean_result,
sphere,
right_circular_cone,
right_circular_cylinder,
torus,
block,
primitive_2d,
right_angular_wedge,
ellipsoid,
faceted_primitive,
rectangular_pyramid,
cyclide_segment_solid,
volume,
half_space_solid,
shell_based_surface_model,
face_based_surface_model,
shell_based_wireframe_model,
edge_based_wireframe_model,
geometric_set,
tessellated_item,
volume_with_faces,
scanned_data_item))
SUBTYPE OF (representation_item);
DERIVE
dim : dimension_count := dimension_of(SELF);
WHERE
WR1: SIZEOF (QUERY (using_rep <* using_representations (SELF) | NOT ('GEOMETRY_SCHEMA.GEOMETRIC_REPRESENTATION_CONTEXT' IN
TYPEOF (using_rep.context_of_items)))) = 0;
END_ENTITY;
ENTITY point
SUPERTYPE OF
(ONEOF (cartesian_point,
point_on_curve,
point_on_surface,
point_in_volume,
point_replica,
degenerate_pcurve))
SUBTYPE OF (geometric_representation_item);
END_ENTITY;
ENTITY cartesian_point
SUPERTYPE OF
(ONEOF (cylindrical_point,
polar_point,
spherical_point))
SUBTYPE OF (point);
coordinates : LIST[1:3] OF length_measure;
END_ENTITY;
ENTITY cylindrical_point
SUBTYPE OF (cartesian_point);
r : length_measure;
theta : plane_angle_measure;
z : length_measure;
DERIVE
SELF\cartesian_point.coordinates : LIST[3:3] OF length_measure := [r*cos(theta), r*sin(theta), z];
WHERE
WR1: r >= 0.0;
END_ENTITY;
ENTITY spherical_point
SUBTYPE OF (cartesian_point);
r : length_measure;
theta : plane_angle_measure;
phi : plane_angle_measure;
DERIVE
SELF\cartesian_point.coordinates : LIST[3:3] OF length_measure := [r*sin(theta)*cos(phi), r*sin(theta)*sin(phi), r*cos(theta)];
WHERE
WR1: r >= 0.0;
END_ENTITY;
ENTITY polar_point
SUBTYPE OF (cartesian_point);
r : length_measure;
theta : plane_angle_measure;
DERIVE
SELF\cartesian_point.coordinates : LIST[2:2] OF length_measure := [r*cos(theta), r*sin(theta)];
WHERE
WR1: r >= 0.0;
END_ENTITY;
ENTITY point_on_curve
SUBTYPE OF (point);
basis_curve : curve;
point_parameter : parameter_value;
END_ENTITY;
ENTITY point_on_surface
SUBTYPE OF (point);
basis_surface : surface;
point_parameter_u : parameter_value;
point_parameter_v : parameter_value;
END_ENTITY;
ENTITY point_in_volume
SUBTYPE OF (point);
basis_volume : volume;
point_parameter_u : parameter_value;
point_parameter_v : parameter_value;
point_parameter_w : parameter_value;
END_ENTITY;
ENTITY point_replica
SUBTYPE OF (point);
parent_pt : point;
transformation : cartesian_transformation_operator;
WHERE
WR1: transformation.dim = parent_pt.dim;
WR2: acyclic_point_replica (SELF,parent_pt);
END_ENTITY;
ENTITY degenerate_pcurve
SUBTYPE OF (point);
basis_surface : surface;
reference_to_curve : definitional_representation;
WHERE
WR1: SIZEOF(reference_to_curve\representation.items) = 1;
WR2: 'GEOMETRY_SCHEMA.CURVE' IN TYPEOF (reference_to_curve\representation.items[1]);
WR3: reference_to_curve\representation. items[1]\geometric_representation_item.dim =2;
END_ENTITY;
ENTITY evaluated_degenerate_pcurve
SUBTYPE OF (degenerate_pcurve);
equivalent_point : cartesian_point;
END_ENTITY;
ENTITY direction
SUBTYPE OF (geometric_representation_item);
direction_ratios : LIST[2:3] OF REAL;
WHERE
WR1: SIZEOF(QUERY(tmp <* direction_ratios | tmp <> 0.0)) > 0;
END_ENTITY;
ENTITY vector
SUBTYPE OF (geometric_representation_item);
orientation : direction;
magnitude : length_measure;
WHERE
WR1: magnitude >= 0.0;
END_ENTITY;
ENTITY placement
SUPERTYPE OF
(ONEOF (axis1_placement,
axis2_placement_2d,
axis2_placement_3d))
SUBTYPE OF (geometric_representation_item);
location : cartesian_point;
END_ENTITY;
ENTITY axis1_placement
SUBTYPE OF (placement);
axis :
OPTIONAL
direction;
DERIVE
z : direction := NVL(normalise(axis), dummy_gri || direction([0.0,0.0,1.0]));
WHERE
WR1: SELF\geometric_representation_item.dim = 3;
END_ENTITY;
ENTITY axis2_placement_2d
SUBTYPE OF (placement);
ref_direction :
OPTIONAL
direction;
DERIVE
p : LIST[2:2] OF direction := build_2axes(ref_direction);
WHERE
WR1: SELF\geometric_representation_item.dim = 2;
END_ENTITY;
ENTITY axis2_placement_3d
SUBTYPE OF (placement);
axis :
OPTIONAL
direction;
ref_direction :
OPTIONAL
direction;
DERIVE
p : LIST[3:3] OF direction := build_axes(axis,ref_direction);
WHERE
WR1: SELF\placement.location.dim = 3;
WR2: (NOT (EXISTS (axis))) OR (axis.dim = 3);
WR3: (NOT (EXISTS (ref_direction))) OR (ref_direction.dim = 3);
WR4: (NOT (EXISTS (axis))) OR (NOT (EXISTS (ref_direction))) OR (cross_product(axis,ref_direction).magnitude > 0.0);
END_ENTITY;
ENTITY cartesian_transformation_operator
SUPERTYPE OF
(ONEOF (cartesian_transformation_operator_2d,
cartesian_transformation_operator_3d))
SUBTYPE OF (geometric_representation_item, functionally_defined_transformation);
axis1 :
OPTIONAL
direction;
axis2 :
OPTIONAL
direction;
local_origin : cartesian_point;
scale :
OPTIONAL
REAL;
DERIVE
scl : REAL := NVL(scale, 1.0);
WHERE
WR1: scl > 0.0;
END_ENTITY;
ENTITY cartesian_transformation_operator_3d
SUBTYPE OF (cartesian_transformation_operator);
axis3 :
OPTIONAL
direction;
DERIVE
u : LIST[3:3] OF direction := base_axis(3,SELF\cartesian_transformation_operator.axis1, SELF\cartesian_transformation_operator.axis2,axis3);
WHERE
WR1: SELF\geometric_representation_item.dim = 3;
END_ENTITY;
ENTITY cartesian_transformation_operator_2d
SUBTYPE OF (cartesian_transformation_operator);
DERIVE
u : LIST[2:2] OF direction := base_axis(2,SELF\cartesian_transformation_operator.axis1, SELF\cartesian_transformation_operator.axis2,?);
WHERE
WR1: SELF\geometric_representation_item.dim = 2;
END_ENTITY;
ENTITY curve
SUPERTYPE OF
(ONEOF (line,
conic,
clothoid,
circular_involute,
pcurve,
surface_curve,
offset_curve_2d,
offset_curve_3d,
curve_replica))
SUBTYPE OF (geometric_representation_item);
END_ENTITY;
ENTITY line
SUBTYPE OF (curve);
pnt : cartesian_point;
dir : vector;
WHERE
WR1: dir.dim = pnt.dim;
END_ENTITY;
ENTITY conic
SUPERTYPE OF
(ONEOF (circle,
ellipse,
hyperbola,
parabola))
SUBTYPE OF (curve);
position : axis2_placement;
END_ENTITY;
ENTITY circle
SUBTYPE OF (conic);
radius : positive_length_measure;
END_ENTITY;
ENTITY ellipse
SUBTYPE OF (conic);
semi_axis_1 : positive_length_measure;
semi_axis_2 : positive_length_measure;
END_ENTITY;
ENTITY hyperbola
SUBTYPE OF (conic);
semi_axis : positive_length_measure;
semi_imag_axis : positive_length_measure;
END_ENTITY;
ENTITY parabola
SUBTYPE OF (conic);
focal_dist : length_measure;
WHERE
WR1: focal_dist <> 0.0;
END_ENTITY;
ENTITY clothoid
SUBTYPE OF (curve);
position : axis2_placement;
clothoid_constant : length_measure;
END_ENTITY;
ENTITY circular_involute
SUBTYPE OF (curve);
position : axis2_placement;
base_radius : positive_length_measure;
END_ENTITY;
ENTITY bounded_curve
SUPERTYPE OF
(ONEOF (polyline,
b_spline_curve,
trimmed_curve,
bounded_pcurve,
bounded_surface_curve,
composite_curve,
locally_refined_spline_curve))
SUBTYPE OF (curve);
END_ENTITY;
ENTITY polyline
SUBTYPE OF (bounded_curve);
points : LIST[2:?] OF cartesian_point;
END_ENTITY;
ENTITY b_spline_curve
SUPERTYPE OF
(ONEOF (uniform_curve,
b_spline_curve_with_knots,
quasi_uniform_curve,
bezier_curve)
ANDOR rational_b_spline_curve)
SUBTYPE OF (bounded_curve);
degree : INTEGER;
control_points_list : LIST[2:?] OF cartesian_point;
curve_form : b_spline_curve_form;
closed_curve : LOGICAL;
self_intersect : LOGICAL;
DERIVE
upper_index_on_control_points : INTEGER := (SIZEOF(control_points_list) - 1);
control_points : ARRAY[0:upper_index_on_control_points] OF cartesian_point := list_to_array(control_points_list,0, upper_index_on_control_points);
WHERE
WR1: ('GEOMETRY_SCHEMA.UNIFORM_CURVE' IN TYPEOF(self)) OR ('GEOMETRY_SCHEMA.QUASI_UNIFORM_CURVE' IN TYPEOF(self)) OR ('GEOMETRY_SCHEMA.BEZIER_CURVE'
IN TYPEOF(self)) OR ('GEOMETRY_SCHEMA.B_SPLINE_CURVE_WITH_KNOTS' IN TYPEOF(self));
END_ENTITY;
ENTITY b_spline_curve_with_knots
SUBTYPE OF (b_spline_curve);
knot_multiplicities : LIST[2:?] OF INTEGER;
knots : LIST[2:?] OF parameter_value;
knot_spec : knot_type;
DERIVE
upper_index_on_knots : INTEGER := SIZEOF(knots);
WHERE
WR1: constraints_param_b_spline(degree, upper_index_on_knots, upper_index_on_control_points, knot_multiplicities, knots);
WR2: SIZEOF(knot_multiplicities) = upper_index_on_knots;
END_ENTITY;
ENTITY uniform_curve
SUBTYPE OF (b_spline_curve);
END_ENTITY;
ENTITY quasi_uniform_curve
SUBTYPE OF (b_spline_curve);
END_ENTITY;
ENTITY bezier_curve
SUBTYPE OF (b_spline_curve);
END_ENTITY;
ENTITY rational_b_spline_curve
SUBTYPE OF (b_spline_curve);
weights_data : LIST[2:?] OF REAL;
DERIVE
weights : ARRAY[0:upper_index_on_control_points] OF REAL := list_to_array(weights_data,0, upper_index_on_control_points);
WHERE
WR1: SIZEOF(weights_data) = SIZEOF(SELF\b_spline_curve. control_points_list);
WR2: curve_weights_positive(SELF);
END_ENTITY;
ENTITY local_b_spline
SUBTYPE OF (representation_item);
degree : INTEGER;
knots : LIST[2:?] OF INTEGER;
multiplicities : LIST[2:?] OF INTEGER;
WHERE
WR1: degree > 0;
WR2: SIZEOF(knots) = SIZEOF(multiplicities);
WR3: constraints_param_local_b_spline(degree, knots, multiplicities);
END_ENTITY;
ENTITY locally_refined_spline_curve
SUBTYPE OF (bounded_curve);
b_splines : LIST[2:?] OF local_b_spline;
knot_values : spline_knot_values;
control_points_list : LIST[2:?] OF cartesian_point;
scaling_factors : LIST[2:?] OF REAL;
closed_curve : LOGICAL;
locally_refined_spline_type : locally_refined_spline_type_enum;
self_intersect : LOGICAL;
domain : LIST[2:2] OF REAL;
WHERE
WR1: SIZEOF(b_splines) = SIZEOF(control_points_list);
WR2: SIZEOF(scaling_factors) = SIZEOF(control_points_list);
WR3: constraints_scaling(scaling_factors);
END_ENTITY;
ENTITY rational_locally_refined_spline_curve
SUBTYPE OF (locally_refined_spline_curve);
weights_data : LIST[2:?] OF REAL;
WHERE
WR1: SIZEOF(weights_data) = SIZEOF(SELF\locally_refined_spline_curve.
control_points_list);
WR2: weights_positive(weights_data);
END_ENTITY;
ENTITY trimmed_curve
SUBTYPE OF (bounded_curve);
basis_curve : curve;
trim_1 : SET[1:2] OF trimming_select;
trim_2 : SET[1:2] OF trimming_select;
sense_agreement : BOOLEAN;
master_representation : trimming_preference;
WHERE
WR1: (HIINDEX(trim_1) = 1) OR (TYPEOF(trim_1[1]) <> TYPEOF(trim_1[2]));
WR2: (HIINDEX(trim_2) = 1) OR (TYPEOF(trim_2[1]) <> TYPEOF(trim_2[2]));
END_ENTITY;
ENTITY composite_curve
SUBTYPE OF (bounded_curve);
segments : LIST[1:?] OF composite_curve_segment;
self_intersect : LOGICAL;
DERIVE
n_segments : INTEGER := SIZEOF(segments);
closed_curve : LOGICAL := segments[n_segments].transition <> discontinuous;
WHERE
WR1: ((NOT closed_curve) AND (SIZEOF(QUERY(temp <* segments | temp.transition = discontinuous)) = 1)) OR ((closed_curve) AND
(SIZEOF(QUERY(temp <* segments | temp.transition = discontinuous)) = 0));
END_ENTITY;
ENTITY composite_curve_segment
SUBTYPE OF (founded_item);
transition : transition_code;
same_sense : BOOLEAN;
parent_curve : curve;
INVERSE
using_curves : BAG[1:?] OF composite_curve FOR segments;
WHERE
WR1: ('GEOMETRY_SCHEMA.BOUNDED_CURVE' IN TYPEOF(parent_curve));
END_ENTITY;
ENTITY reparametrised_composite_curve_segment
SUBTYPE OF (composite_curve_segment);
param_length : parameter_value;
WHERE
WR1: param_length > 0.0;
END_ENTITY;
ENTITY pcurve
SUBTYPE OF (curve);
basis_surface : surface;
reference_to_curve : definitional_representation;
WHERE
WR1: SIZEOF(reference_to_curve\representation.items) = 1;
WR2: 'GEOMETRY_SCHEMA.CURVE' IN TYPEOF (reference_to_curve\representation.items[1]);
WR3: reference_to_curve\representation.items[1]\ geometric_representation_item.dim =2;
END_ENTITY;
ENTITY bounded_pcurve
SUBTYPE OF (pcurve, bounded_curve);
WHERE
WR1: ('GEOMETRY_SCHEMA.BOUNDED_CURVE' IN TYPEOF(SELF\pcurve.reference_to_curve.items[1]));
END_ENTITY;
ENTITY surface_curve
SUPERTYPE OF
(ONEOF (intersection_curve,
seam_curve)
ANDOR bounded_surface_curve)
SUBTYPE OF (curve);
curve_3d : curve;
associated_geometry : LIST[1:2] OF pcurve_or_surface;
master_representation : preferred_surface_curve_representation;
DERIVE
basis_surface : SET[1:2] OF surface := get_basis_surface(SELF);
WHERE
WR1: curve_3d.dim = 3;
WR2: ('GEOMETRY_SCHEMA.PCURVE' IN TYPEOF(associated_geometry[1])) OR (master_representation <> pcurve_s1);
WR3: ('GEOMETRY_SCHEMA.PCURVE' IN TYPEOF(associated_geometry[2])) OR (master_representation <> pcurve_s2);
WR4: NOT ('GEOMETRY_SCHEMA.PCURVE' IN TYPEOF(curve_3d));
END_ENTITY;
ENTITY intersection_curve
SUBTYPE OF (surface_curve);
WHERE
WR1: SIZEOF(SELF\surface_curve.associated_geometry) = 2;
WR2: associated_surface(SELF\surface_curve.associated_geometry[1]) <> associated_surface(SELF\surface_curve.associated_geometry[2]);
END_ENTITY;
ENTITY seam_curve
SUBTYPE OF (surface_curve);
WHERE
WR1: SIZEOF(SELF\surface_curve.associated_geometry) = 2;
WR2: associated_surface(SELF\surface_curve.associated_geometry[1]) = associated_surface(SELF\surface_curve.associated_geometry[2]);
WR3: 'GEOMETRY_SCHEMA.PCURVE' IN TYPEOF(SELF\surface_curve.associated_geometry[1]);
WR4: 'GEOMETRY_SCHEMA.PCURVE' IN TYPEOF(SELF\surface_curve.associated_geometry[2]);
END_ENTITY;
ENTITY bounded_surface_curve
SUBTYPE OF (surface_curve, bounded_curve);
WHERE
WR1: ('GEOMETRY_SCHEMA.BOUNDED_CURVE' IN TYPEOF(SELF\surface_curve.curve_3d));
END_ENTITY;
ENTITY composite_curve_on_surface
SUPERTYPE OF
(boundary_curve)
SUBTYPE OF (composite_curve);
DERIVE
basis_surface : SET[0:2] OF surface := get_basis_surface(SELF);
WHERE
WR1: SIZEOF(basis_surface) > 0;
WR2: constraints_composite_curve_on_surface(SELF);
END_ENTITY;
ENTITY offset_curve_2d
SUBTYPE OF (curve);
basis_curve : curve;
distance : length_measure;
self_intersect : LOGICAL;
WHERE
WR1: basis_curve.dim = 2;
END_ENTITY;
ENTITY offset_curve_3d
SUBTYPE OF (curve);
basis_curve : curve;
distance : length_measure;
self_intersect : LOGICAL;
ref_direction : direction;
WHERE
WR1: (basis_curve.dim = 3) AND (ref_direction.dim = 3);
END_ENTITY;
ENTITY curve_replica
SUBTYPE OF (curve);
parent_curve : curve;
transformation : cartesian_transformation_operator;
WHERE
WR1: transformation.dim = parent_curve.dim;
WR2: acyclic_curve_replica (SELF, parent_curve);
END_ENTITY;
ENTITY surface
SUPERTYPE OF
(ONEOF (elementary_surface,
swept_surface,
bounded_surface,
offset_surface,
surface_replica))
SUBTYPE OF (geometric_representation_item);
END_ENTITY;
ENTITY elementary_surface
SUPERTYPE OF
(ONEOF (plane,
cylindrical_surface,
conical_surface,
spherical_surface,
toroidal_surface))
SUBTYPE OF (surface);
position : axis2_placement_3d;
END_ENTITY;
ENTITY plane
SUBTYPE OF (elementary_surface);
END_ENTITY;
ENTITY cylindrical_surface
SUBTYPE OF (elementary_surface);
radius : positive_length_measure;
END_ENTITY;
ENTITY conical_surface
SUBTYPE OF (elementary_surface);
radius : length_measure;
semi_angle : plane_angle_measure;
WHERE
WR1: radius >= 0.0;
END_ENTITY;
ENTITY spherical_surface
SUBTYPE OF (elementary_surface);
radius : positive_length_measure;
END_ENTITY;
ENTITY toroidal_surface
SUBTYPE OF (elementary_surface);
major_radius : positive_length_measure;
minor_radius : positive_length_measure;
END_ENTITY;
ENTITY degenerate_toroidal_surface
SUBTYPE OF (toroidal_surface);
select_outer : BOOLEAN;
WHERE
WR1: major_radius < minor_radius;
END_ENTITY;
ENTITY dupin_cyclide_surface
SUBTYPE OF (elementary_surface);
generalised_major_radius : positive_length_measure;
generalised_minor_radius : positive_length_measure;
skewness : length_measure;
WHERE
WR1: skewness >= 0.0;
END_ENTITY;
ENTITY swept_surface
SUPERTYPE OF
(ONEOF (surface_of_linear_extrusion,
surface_of_revolution,
surface_curve_swept_surface,
fixed_reference_swept_surface))
SUBTYPE OF (surface);
swept_curve : curve;
END_ENTITY;
ENTITY surface_of_linear_extrusion
SUBTYPE OF (swept_surface);
extrusion_axis : vector;
END_ENTITY;
ENTITY surface_of_revolution
SUBTYPE OF (swept_surface);
axis_position : axis1_placement;
DERIVE
axis_line : line := representation_item('')|| geometric_representation_item()|| curve()|| line(axis_position.location, representation_item('')||
geometric_representation_item()|| vector(axis_position.z, 1.0));
END_ENTITY;
ENTITY surface_curve_swept_surface
SUBTYPE OF (swept_surface);
directrix : curve;
reference_surface : surface;
WHERE
WR1: (NOT ('GEOMETRY_SCHEMA.SURFACE_CURVE' IN TYPEOF(directrix))) OR (reference_surface IN (directrix\surface_curve.basis_surface));
END_ENTITY;
ENTITY fixed_reference_swept_surface
SUBTYPE OF (swept_surface);
directrix : curve;
fixed_reference : direction;
END_ENTITY;
ENTITY bounded_surface
SUPERTYPE OF
(ONEOF (b_spline_surface,
rectangular_trimmed_surface,
curve_bounded_surface,
rectangular_composite_surface,
locally_refined_spline_surface))
SUBTYPE OF (surface);
END_ENTITY;
ENTITY b_spline_surface
SUPERTYPE OF
(ONEOF (b_spline_surface_with_knots,
uniform_surface,
quasi_uniform_surface,
bezier_surface)
ANDOR rational_b_spline_surface)
SUBTYPE OF (bounded_surface);
u_degree : INTEGER;
v_degree : INTEGER;
control_points_list : LIST[2:?] OF LIST[2:?] OF cartesian_point;
surface_form : b_spline_surface_form;
u_closed : LOGICAL;
v_closed : LOGICAL;
self_intersect : LOGICAL;
DERIVE
u_upper : INTEGER := SIZEOF(control_points_list) - 1;
v_upper : INTEGER := SIZEOF(control_points_list[1]) - 1;
control_points : ARRAY[0:u_upper] OF ARRAY[0:v_upper] OF cartesian_point := make_array_of_array(control_points_list, 0,u_upper,0,v_upper);
WHERE
WR1: ('GEOMETRY_SCHEMA.UNIFORM_SURFACE' IN TYPEOF(SELF)) OR ('GEOMETRY_SCHEMA.QUASI_UNIFORM_SURFACE' IN TYPEOF(SELF)) OR ('GEOMETRY_SCHEMA.BEZIER_SURFACE'
IN TYPEOF(SELF)) OR ('GEOMETRY_SCHEMA.B_SPLINE_SURFACE_WITH_KNOTS' IN TYPEOF(SELF));
END_ENTITY;
ENTITY b_spline_surface_with_knots
SUBTYPE OF (b_spline_surface);
u_multiplicities : LIST[2:?] OF INTEGER;
v_multiplicities : LIST[2:?] OF INTEGER;
u_knots : LIST[2:?] OF parameter_value;
v_knots : LIST[2:?] OF parameter_value;
knot_spec : knot_type;
DERIVE
knot_u_upper : INTEGER := SIZEOF(u_knots);
knot_v_upper : INTEGER := SIZEOF(v_knots);
WHERE
WR1: constraints_param_b_spline(SELF\b_spline_surface.u_degree, knot_u_upper, SELF\b_spline_surface.u_upper, u_multiplicities,
u_knots);
WR2: constraints_param_b_spline(SELF\b_spline_surface.v_degree, knot_v_upper, SELF\b_spline_surface.v_upper, v_multiplicities,
v_knots);
WR3: SIZEOF(u_multiplicities) = knot_u_upper;
WR4: SIZEOF(v_multiplicities) = knot_v_upper;
END_ENTITY;
ENTITY uniform_surface
SUBTYPE OF (b_spline_surface);
END_ENTITY;
ENTITY quasi_uniform_surface
SUBTYPE OF (b_spline_surface);
END_ENTITY;
ENTITY bezier_surface
SUBTYPE OF (b_spline_surface);
END_ENTITY;
ENTITY rational_b_spline_surface
SUBTYPE OF (b_spline_surface);
weights_data : LIST[2:?] OF LIST[2:?] OF REAL;
DERIVE
weights : ARRAY[0:u_upper] OF ARRAY[0:v_upper] OF REAL := make_array_of_array(weights_data,0,u_upper,0,v_upper);
WHERE
WR1: (SIZEOF(weights_data) = SIZEOF(SELF\b_spline_surface.control_points_list)) AND (SIZEOF(weights_data[1]) = SIZEOF(SELF\b_spline_surface.control_points_list[1]));
WR2: surface_weights_positive(SELF);
END_ENTITY;
ENTITY locally_refined_spline_surface
SUBTYPE OF (bounded_surface);
u_b_splines : LIST[4:?] OF local_b_spline;
v_b_splines : LIST[4:?] OF local_b_spline;
u_knots : spline_knot_values;
v_knots : spline_knot_values;
control_points_list : LIST[4:?] OF cartesian_point;
scaling_factors : LIST[4:?] OF REAL;
linearly_independent : linearly_independent_enum;
locally_refined_spline_type : locally_refined_spline_type_enum;
self_intersect : LOGICAL;
u_closed : LOGICAL;
v_closed : LOGICAL;
domain : LIST[2:2] OF LIST[2:2] OF REAL;
WHERE
WR1: SIZEOF(u_b_splines) = SIZEOF(control_points_list);
WR2: SIZEOF(v_b_splines) = SIZEOF(control_points_list);
WR3: SIZEOF(scaling_factors) = SIZEOF(control_points_list);
WR4: constraints_scaling(scaling_factors);
END_ENTITY;
ENTITY rational_locally_refined_spline_surface
SUBTYPE OF (locally_refined_spline_surface);
weights_data : LIST[4:?] OF REAL;
WHERE
WR1: SIZEOF(weights_data) = SIZEOF(SELF\locally_refined_spline_surface.
control_points_list);
WR2: weights_positive(weights_data);
END_ENTITY;
ENTITY rectangular_trimmed_surface
SUBTYPE OF (bounded_surface);
basis_surface : surface;
u1 : parameter_value;
u2 : parameter_value;
v1 : parameter_value;
v2 : parameter_value;
usense : BOOLEAN;
vsense : BOOLEAN;
WHERE
WR1: u1 <> u2;
WR2: v1 <> v2;
WR3: (('GEOMETRY_SCHEMA.ELEMENTARY_SURFACE' IN TYPEOF(basis_surface)) AND (NOT ('GEOMETRY_SCHEMA.PLANE' IN TYPEOF(basis_surface))))
OR ('GEOMETRY_SCHEMA.SURFACE_OF_REVOLUTION' IN TYPEOF(basis_surface)) OR (usense = (u2 > u1));
WR4: (('GEOMETRY_SCHEMA.SPHERICAL_SURFACE' IN TYPEOF(basis_surface)) OR ('GEOMETRY_SCHEMA.TOROIDAL_SURFACE' IN TYPEOF(basis_surface)))
OR (vsense = (v2 > v1));
END_ENTITY;
ENTITY curve_bounded_surface
SUBTYPE OF (bounded_surface);
basis_surface : surface;
boundaries : SET[1:?] OF boundary_curve;
implicit_outer : BOOLEAN;
WHERE
WR1: (NOT implicit_outer) OR (SIZEOF (QUERY (temp <* boundaries | 'GEOMETRY_SCHEMA.OUTER_BOUNDARY_CURVE' IN TYPEOF(temp)))
= 0);
WR2: (NOT(implicit_outer)) OR ('GEOMETRY_SCHEMA.BOUNDED_SURFACE' IN TYPEOF(basis_surface));
WR3: SIZEOF(QUERY(temp <* boundaries | 'GEOMETRY_SCHEMA.OUTER_BOUNDARY_CURVE' IN TYPEOF(temp))) <= 1;
WR4: SIZEOF(QUERY(temp <* boundaries | (temp\composite_curve_on_surface.basis_surface [1] <> basis_surface))) = 0;
END_ENTITY;
ENTITY boundary_curve
SUBTYPE OF (composite_curve_on_surface);
WHERE
WR1: SELF\composite_curve.closed_curve;
END_ENTITY;
ENTITY outer_boundary_curve
SUBTYPE OF (boundary_curve);
END_ENTITY;
ENTITY rectangular_composite_surface
SUBTYPE OF (bounded_surface);
segments : LIST[1:?] OF LIST[1:?] OF surface_patch;
DERIVE
n_u : INTEGER := SIZEOF(segments);
n_v : INTEGER := SIZEOF(segments[1]);
WHERE
WR1: SIZEOF(QUERY (s <* segments | n_v <> SIZEOF (s))) = 0;
WR2: constraints_rectangular_composite_surface(SELF);
END_ENTITY;
ENTITY surface_patch
SUBTYPE OF (founded_item);
parent_surface : bounded_surface;
u_transition : transition_code;
v_transition : transition_code;
u_sense : BOOLEAN;
v_sense : BOOLEAN;
INVERSE
using_surfaces : BAG[1:?] OF rectangular_composite_surface FOR segments;
WHERE
WR1: (NOT ('GEOMETRY_SCHEMA.CURVE_BOUNDED_SURFACE' IN TYPEOF(parent_surface)));
END_ENTITY;
ENTITY offset_surface
SUBTYPE OF (surface);
basis_surface : surface;
distance : length_measure;
self_intersect : LOGICAL;
END_ENTITY;
ENTITY oriented_surface
SUBTYPE OF (surface);
orientation : BOOLEAN;
END_ENTITY;
ENTITY surface_replica
SUBTYPE OF (surface);
parent_surface : surface;
transformation : cartesian_transformation_operator_3d;
WHERE
WR1: acyclic_surface_replica(SELF, parent_surface);
END_ENTITY;
ENTITY volume
SUPERTYPE OF
(ONEOF (block_volume,
wedge_volume,
spherical_volume,
cylindrical_volume,
eccentric_conical_volume,
toroidal_volume,
pyramid_volume,
b_spline_volume,
ellipsoid_volume,
tetrahedron_volume,
hexahedron_volume,
locally_refined_spline_volume))
SUBTYPE OF (geometric_representation_item);
WHERE
WR1: SELF\geometric_representation_item.dim = 3;
END_ENTITY;
ENTITY block_volume
SUBTYPE OF (volume);
position : axis2_placement_3d;
x : positive_length_measure;
y : positive_length_measure;
z : positive_length_measure;
END_ENTITY;
ENTITY wedge_volume
SUBTYPE OF (volume);
position : axis2_placement_3d;
x : positive_length_measure;
y : positive_length_measure;
z : positive_length_measure;
ltx : length_measure;
WHERE
WR1: ((0.0 <= ltx) AND (ltx < x));
END_ENTITY;
ENTITY pyramid_volume
SUBTYPE OF (volume);
position : axis2_placement_3d;
xlength : positive_length_measure;
ylength : positive_length_measure;
height : positive_length_measure;
END_ENTITY;
ENTITY tetrahedron_volume
SUBTYPE OF (volume);
point_1 : cartesian_point;
point_2 : cartesian_point;
point_3 : cartesian_point;
point_4 : cartesian_point;
WHERE
WR1: point_1.dim = 3;
WR2: above_plane(point_1, point_2, point_3, point_4) <> 0.0;
END_ENTITY;
ENTITY hexahedron_volume
SUBTYPE OF (volume);
points : LIST[8:8] OF cartesian_point;
WHERE
WR1: above_plane(points[1], points[2], points[3], points[4]) = 0.0;
WR2: above_plane(points[5], points[8], points[7], points[6]) = 0.0;
WR3: above_plane(points[1], points[4], points[8], points[5]) = 0.0;
WR4: above_plane(points[4], points[3], points[7], points[8]) = 0.0;
WR5: above_plane(points[3], points[2], points[6], points[7]) = 0.0;
WR6: above_plane(points[1], points[5], points[6], points[2]) = 0.0;
WR7: same_side([points[1], points[2], points[3]], [points[5], points[6], points[7], points[8]]);
WR8: same_side([points[1], points[4], points[8]], [points[3], points[7], points[6], points[2]]);
WR9: same_side([points[1], points[2], points[5]], [points[3], points[7], points[8], points[4]]);
WR10: same_side([points[5], points[6], points[7]], [points[1], points[2], points[3], points[4]]);
WR11: same_side([points[3], points[7], points[6]], [points[1], points[4], points[8], points[5]]);
WR12: same_side([points[3], points[7], points[8]], [points[1], points[5], points[6], points[2]]);
WR13: points[1].dim = 3;
END_ENTITY;
ENTITY spherical_volume
SUBTYPE OF (volume);
position : axis2_placement_3d;
radius : positive_length_measure;
END_ENTITY;
ENTITY cylindrical_volume
SUBTYPE OF (volume);
position : axis2_placement_3d;
radius : positive_length_measure;
height : positive_length_measure;
END_ENTITY;
ENTITY eccentric_conical_volume
SUBTYPE OF (volume);
position : axis2_placement_3d;
semi_axis_1 : positive_length_measure;
semi_axis_2 : positive_length_measure;
height : positive_length_measure;
x_offset : length_measure;
y_offset : length_measure;
ratio : REAL;
WHERE
WR1: ratio >= 0.0;
END_ENTITY;
ENTITY toroidal_volume
SUBTYPE OF (volume);
position : axis2_placement_3d;
major_radius : positive_length_measure;
minor_radius : positive_length_measure;
WHERE
WR1: minor_radius < major_radius;
END_ENTITY;
ENTITY ellipsoid_volume
SUBTYPE OF (volume);
position : axis2_placement_3d;
semi_axis_1 : positive_length_measure;
semi_axis_2 : positive_length_measure;
semi_axis_3 : positive_length_measure;
END_ENTITY;
ENTITY b_spline_volume
SUPERTYPE OF
(ONEOF (b_spline_volume_with_knots,
uniform_volume,
quasi_uniform_volume,
bezier_volume)
ANDOR rational_b_spline_volume)
SUBTYPE OF (volume);
u_degree : INTEGER;
v_degree : INTEGER;
w_degree : INTEGER;
control_points_list : LIST[2:?] OF LIST[2:?] OF LIST[2:?] OF cartesian_point;
DERIVE
u_upper : INTEGER := SIZEOF(control_points_list) - 1;
v_upper : INTEGER := SIZEOF(control_points_list[1]) - 1;
w_upper : INTEGER := SIZEOF(control_points_list[1][1]) - 1;
control_points : ARRAY[0:u_upper] OF ARRAY[0:v_upper] OF ARRAY[0:w_upper] OF cartesian_point := make_array_of_array_of_array (control_points_list, 0,u_upper,0,v_upper, 0,w_upper );
WHERE
WR1: ('GEOMETRY_SCHEMA.BEZIER_VOLUME' IN TYPEOF(SELF)) OR ('GEOMETRY_SCHEMA.UNIFORM_VOLUME' IN TYPEOF(SELF)) OR ('GEOMETRY_SCHEMA.QUASI_UNIFORM_VOLUME'
IN TYPEOF(SELF)) OR ('GEOMETRY_SCHEMA.B_SPLINE_VOLUME_WITH_KNOTS' IN TYPEOF(SELF));
END_ENTITY;
ENTITY b_spline_volume_with_knots
SUBTYPE OF (b_spline_volume);
u_multiplicities : LIST[2:?] OF INTEGER;
v_multiplicities : LIST[2:?] OF INTEGER;
w_multiplicities : LIST[2:?] OF INTEGER;
u_knots : LIST[2:?] OF parameter_value;
v_knots : LIST[2:?] OF parameter_value;
w_knots : LIST[2:?] OF parameter_value;
DERIVE
knot_u_upper : INTEGER := SIZEOF(u_knots);
knot_v_upper : INTEGER := SIZEOF(v_knots);
knot_w_upper : INTEGER := SIZEOF(w_knots);
WHERE
WR1: constraints_param_b_spline(SELF\b_spline_volume.u_degree, knot_u_upper, SELF\b_spline_volume.u_upper, u_multiplicities,
u_knots);
WR2: constraints_param_b_spline(SELF\b_spline_volume.v_degree, knot_v_upper, SELF\b_spline_volume.v_upper, v_multiplicities,
v_knots);
WR3: constraints_param_b_spline(SELF\b_spline_volume.w_degree, knot_w_upper, SELF\b_spline_volume.w_upper, w_multiplicities,
w_knots);
WR4: SIZEOF(u_multiplicities) = knot_u_upper;
WR5: SIZEOF(v_multiplicities) = knot_v_upper;
WR6: SIZEOF(w_multiplicities) = knot_w_upper;
END_ENTITY;
ENTITY bezier_volume
SUBTYPE OF (b_spline_volume);
END_ENTITY;
ENTITY uniform_volume
SUBTYPE OF (b_spline_volume);
END_ENTITY;
ENTITY quasi_uniform_volume
SUBTYPE OF (b_spline_volume);
END_ENTITY;
ENTITY rational_b_spline_volume
SUBTYPE OF (b_spline_volume);
weights_data : LIST[2:?] OF LIST[2:?] OF LIST[2:?] OF REAL;
DERIVE
weights : ARRAY[0:u_upper] OF ARRAY[0:v_upper] OF ARRAY[0:w_upper] OF REAL := make_array_of_array_of_array (weights_data,0,u_upper,0,v_upper,0,w_upper);
WHERE
WR1: (SIZEOF(weights_data) = SIZEOF(SELF\b_spline_volume.control_points_list)) AND (SIZEOF(weights_data[1]) = SIZEOF(SELF\b_spline_volume.control_points_list[1]))
AND (SIZEOF(weights_data[1][1]) = SIZEOF(SELF\b_spline_volume.control_points_list[1][1]));
WR2: volume_weights_positive(SELF);
END_ENTITY;
ENTITY locally_refined_spline_volume
SUBTYPE OF (volume);
u_b_splines : LIST[8:?] OF local_b_spline;
v_b_splines : LIST[8:?] OF local_b_spline;
w_b_splines : LIST[8:?] OF local_b_spline;
u_knots : spline_knot_values;
v_knots : spline_knot_values;
w_knots : spline_knot_values;
control_points_list : LIST[8:?] OF cartesian_point;
scaling_factors : LIST[8:?] OF REAL;
linearly_independent : linearly_independent_enum;
locally_refined_spline_type : locally_refined_spline_type_enum;
domain : LIST[3:3] OF LIST[2:2] OF REAL;
WHERE
WR1: SIZEOF(u_b_splines) = SIZEOF(control_points_list);
WR2: SIZEOF(v_b_splines) = SIZEOF(control_points_list);
WR3: SIZEOF(w_b_splines) = SIZEOF(control_points_list);
WR4: SIZEOF(scaling_factors) = SIZEOF(control_points_list);
WR5: constraints_scaling(scaling_factors);
END_ENTITY;
ENTITY rational_locally_refined_spline_volume
SUBTYPE OF (locally_refined_spline_volume);
weights_data : LIST[8:?] OF REAL;
WHERE
WR1: SIZEOF(weights_data) = SIZEOF(SELF\locally_refined_spline_volume.control_points_list);
WR2: weights_positive(weights_data);
END_ENTITY;
RULE
compatible_dimension FOR
(cartesian_point,direction,geometric_representation_context);
WHERE
WR1: ((SIZEOF(cartesian_point) = 0) AND (SIZEOF(direction) = 0) AND (SIZEOF(geometric_representation_context) = 0)) OR
check_geometric_dimension(cartesian_point, direction, geometric_representation_context);
END_RULE;
FUNCTION above_plane
(p1 : cartesian_point; p2 : cartesian_point; p3 : cartesian_point; p4 : cartesian_point) : REAL;
LOCAL
dir2, dir3, dir4 : direction :=
dummy_gri || direction([1.0, 0.0, 0.0]);
val, mag : REAL;
END_LOCAL;
IF (p1.dim <> 3) THEN
RETURN(?);
END_IF;
REPEAT i := 1 TO 3;
dir2.direction_ratios[i] := p2.coordinates[i] - p1.coordinates[i];
dir3.direction_ratios[i] := p3.coordinates[i] - p1.coordinates[i];
dir4.direction_ratios[i] := p4.coordinates[i] - p1.coordinates[i];
mag := dir4.direction_ratios[i]*dir4.direction_ratios[i];
END_REPEAT;
mag := sqrt(mag);
val := mag*dot_product(dir4, cross_product(dir2, dir3).orientation);
RETURN(val);
END_FUNCTION;
FUNCTION acyclic_curve_replica
(rep : curve_replica; parent : curve) : BOOLEAN;
IF NOT (('GEOMETRY_SCHEMA.CURVE_REPLICA') IN TYPEOF(parent)) THEN
RETURN (TRUE);
END_IF;
(* Return TRUE if the parent is not of type curve_replica *)
IF (parent :=: rep) THEN
RETURN (FALSE);
(* Return FALSE if the parent is the same curve_replica, otherwise,
call function again with the parents own parent_curve. *)
ELSE
RETURN(acyclic_curve_replica(rep,
parent\curve_replica.parent_curve));
END_IF;
END_FUNCTION;
FUNCTION acyclic_point_replica
(rep : point_replica; parent : point) : BOOLEAN;
IF NOT (('GEOMETRY_SCHEMA.POINT_REPLICA') IN TYPEOF(parent)) THEN
RETURN (TRUE);
END_IF;
(* Return TRUE if the parent is not of type point_replica *)
IF (parent :=: rep) THEN
RETURN (FALSE);
(* Return FALSE if the parent is the same point_replica, otherwise,
call function again with the parents own parent_pt. *)
ELSE RETURN(acyclic_point_replica(rep, parent\point_replica.parent_pt));
END_IF;
END_FUNCTION;
FUNCTION acyclic_surface_replica
(rep : surface_replica; parent : surface) : BOOLEAN;
IF NOT (('GEOMETRY_SCHEMA.SURFACE_REPLICA') IN TYPEOF(parent)) THEN
RETURN (TRUE);
END_IF;
(* Return TRUE if the parent is not of type surface_replica *)
IF (parent :=: rep) THEN
RETURN (FALSE);
(* Return FALSE if the parent is the same surface_replica, otherwise,
call function again with the parents own parent_surface. *)
ELSE RETURN(acyclic_surface_replica(rep,
parent\surface_replica.parent_surface));
END_IF;
END_FUNCTION;
FUNCTION associated_surface
(arg : pcurve_or_surface) : surface;
LOCAL
surf : surface;
END_LOCAL;
IF 'GEOMETRY_SCHEMA.PCURVE' IN TYPEOF(arg) THEN
surf := arg\pcurve.basis_surface;
ELSE
surf := arg;
END_IF;
RETURN(surf);
END_FUNCTION;
FUNCTION base_axis
(dim : INTEGER; axis1 : direction; axis2 : direction; axis3 : direction) : LIST[2:3] OF direction;
LOCAL
u : LIST [2:3] OF direction;
factor : REAL;
d1, d2 : direction;
END_LOCAL;
IF (dim = 3) THEN
d1 := NVL(normalise(axis3), dummy_gri || direction([0.0,0.0,1.0]));
d2 := first_proj_axis(d1,axis1);
u := [d2, second_proj_axis(d1,d2,axis2), d1];
ELSE
IF EXISTS(axis1) THEN
d1 := normalise(axis1);
u := [d1, orthogonal_complement(d1)];
IF EXISTS(axis2) THEN
factor := dot_product(axis2,u[2]);
IF (factor < 0.0) THEN
u[2].direction_ratios[1] := -u[2].direction_ratios[1];
u[2].direction_ratios[2] := -u[2].direction_ratios[2];
END_IF;
END_IF;
ELSE
IF EXISTS(axis2) THEN
d1 := normalise(axis2);
u := [orthogonal_complement(d1), d1];
u[1].direction_ratios[1] := -u[1].direction_ratios[1];
u[1].direction_ratios[2] := -u[1].direction_ratios[2];
ELSE
u := [dummy_gri || direction([1.0, 0.0]), dummy_gri ||
direction([0.0, 1.0])];
END_IF;
END_IF;
END_IF;
RETURN(u);
END_FUNCTION;
FUNCTION build_2axes
(ref_direction : direction) : LIST[2:2] OF direction;
LOCAL
d : direction := NVL(normalise(ref_direction),
dummy_gri || direction([1.0,0.0]));
END_LOCAL;
RETURN([d, orthogonal_complement(d)]);
END_FUNCTION;
FUNCTION build_axes
(axis : direction; ref_direction : direction) : LIST[3:3] OF direction;
LOCAL
d1, d2 : direction;
END_LOCAL;
d1 := NVL(normalise(axis), dummy_gri || direction([0.0,0.0,1.0]));
d2 := first_proj_axis(d1, ref_direction);
RETURN([d2, normalise(cross_product(d1,d2))\vector.orientation, d1]);
END_FUNCTION;
FUNCTION check_geometric_dimension
(capt : SET[0:?] OF cartesian_point; dir : SET[0:?] OF direction; grc : SET[1:?] OF geometric_representation_context) : BOOLEAN;
LOCAL
globaldim : INTEGER := 0; (* means mixed dimensionality *)
reps : SET [0:?] OF representation := [];
result : BOOLEAN := TRUE; (* means no error *)
END_LOCAL;
globaldim:= geometric_dimensionalities_in_contexts(grc);
IF (globaldim > 0) then
(* Same dimension for all contexts; only one check needed. *)
IF (SIZEOF(capt) > 0) THEN
REPEAT i := 1 TO HIINDEX(capt);
IF (HIINDEX(capt[i].coordinates) <> globaldim) THEN
RETURN(FALSE);
END_IF;
END_REPEAT;
END_IF;
IF (SIZEOF(dir) > 0) THEN
REPEAT i := 1 TO HIINDEX(dir);
IF (HIINDEX(dir[i].direction_ratios) <> globaldim) THEN
RETURN(FALSE);
END_IF;
END_REPEAT;
END_IF;
RETURN(result);
ELSE
(* globaldim=0, mixed dimensions for contexts; check needed for context of each representation in which gri is used. *)
IF (SIZEOF(capt) > 0) THEN
REPEAT i := 1 TO HIINDEX(capt);
reps := using_representations(capt[i]);
IF (SIZEOF(reps) > 0) THEN
REPEAT j := 1 TO HIINDEX(reps);
IF (HIINDEX(capt[i].coordinates) <> reps[j].context_of_items\geometric_representation_context.coordinate_space_dimension) THEN
RETURN(FALSE);
END_IF;
END_REPEAT;
ELSE (* zero reps *)
RETURN(FALSE);
END_IF;
END_REPEAT;
END_IF;
IF (SIZEOF(dir) > 0) THEN
REPEAT i := 1 TO HIINDEX(dir);
(* globaldim=0, Mixed dimensions for contexts, check needed for context of each representation in which gri is used *)
reps := using_representations(dir[i]);
IF (SIZEOF(reps) > 0) THEN
REPEAT j := 1 TO HIINDEX(reps);
IF (HIINDEX(dir[i].direction_ratios) <> reps[j].context_of_items\geometric_representation_context.coordinate_space_dimension) THEN
RETURN(FALSE);
END_IF;
END_REPEAT;
ELSE (* zero reps *)
RETURN(FALSE);
END_IF;
END_REPEAT;
END_IF;
END_IF;
RETURN(result);
END_FUNCTION;
FUNCTION constraints_composite_curve_on_surface
(c : composite_curve_on_surface) : BOOLEAN;
LOCAL
n_segments : INTEGER := SIZEOF(c.segments);
END_LOCAL;
REPEAT k := 1 TO n_segments;
IF (NOT('GEOMETRY_SCHEMA.PCURVE' IN
TYPEOF(c\composite_curve.segments[k].parent_curve))) AND
(NOT('GEOMETRY_SCHEMA.SURFACE_CURVE' IN
TYPEOF(c\composite_curve.segments[k].parent_curve))) AND
(NOT('GEOMETRY_SCHEMA.COMPOSITE_CURVE_ON_SURFACE' IN
TYPEOF(c\composite_curve.segments[k].parent_curve))) THEN
RETURN (FALSE);
END_IF;
END_REPEAT;
RETURN(TRUE);
END_FUNCTION;
FUNCTION constraints_param_b_spline
(degree : INTEGER; up_knots : INTEGER; up_cp : INTEGER; knot_mult : LIST[0:?] OF INTEGER; knots : LIST[0:?] OF parameter_value) : BOOLEAN;
LOCAL
result : BOOLEAN := TRUE;
k, sum : INTEGER;
END_LOCAL;
(* Find sum of knot multiplicities. *)
sum := knot_mult[1];
REPEAT i := 2 TO up_knots;
sum := sum + knot_mult[i];
END_REPEAT;
(* Check limits holding for all B-spline parametrisations *)
IF (degree < 1) OR (up_knots < 2) OR (up_cp < degree) OR
(sum <> (degree + up_cp + 2)) THEN
result := FALSE;
RETURN(result);
END_IF;
k := knot_mult[1];
IF (k < 1) OR (k > degree + 1) THEN
result := FALSE;
RETURN(result);
END_IF;
REPEAT i := 2 TO up_knots;
IF (knot_mult[i] < 1) OR (knots[i] <= knots[i-1]) THEN
result := FALSE;
RETURN(result);
END_IF;
k := knot_mult[i];
IF (i < up_knots) AND (k > degree) THEN
result := FALSE;
RETURN(result);
END_IF;
IF (i = up_knots) AND (k > degree + 1) THEN
result := FALSE;
RETURN(result);
END_IF;
END_REPEAT;
RETURN(result);
END_FUNCTION;
FUNCTION constraints_param_local_b_spline
(degree : INTEGER; knot_mult : LIST[0:?] OF INTEGER; knots : LIST[0:?] OF INTEGER) : BOOLEAN;
LOCAL result : BOOLEAN := TRUE; k, up_knots, sum : INTEGER; END_LOCAL; (* Find sum of knot multiplicities. *) up_knots := SIZEOF(knots); sum := knot_mult[1]; REPEAT i := 2 TO up_knots; sum := sum + knot_mult[i]; END_REPEAT; (* Check limits holding for all B-spline parametrisations *) IF (degree < 1) OR (up_knots < 2) OR (sum <> (degree + 2)) THEN result := FALSE; RETURN(result); END_IF; k := knot_mult[1]; IF (k < 1) OR (k > degree + 1) THEN result := FALSE; RETURN(result); END_IF; (* first pointer shall be 1 or more *) IF (knots[1] < 1) THEN result := FALSE; END_IF; REPEAT i := 2 TO up_knots; IF (knot_mult[i] < 1) OR (knots[i] <= knots[i-1]) THEN result := FALSE; RETURN(result); END_IF; k := knot_mult[i]; IF (i < up_knots) AND (k > degree) THEN result := FALSE; RETURN(result); END_IF; IF (i = up_knots) AND (k > degree + 1) THEN result := FALSE; RETURN(result); END_IF; END_REPEAT; RETURN(result);
END_FUNCTION;
FUNCTION constraints_rectangular_composite_surface
(s : rectangular_composite_surface) : BOOLEAN;
REPEAT i := 1 TO s.n_u;
REPEAT j := 1 TO s.n_v;
IF NOT (('GEOMETRY_SCHEMA.B_SPLINE_SURFACE' IN TYPEOF
(s.segments[i][j].parent_surface)) OR
('GEOMETRY_SCHEMA.RECTANGULAR_TRIMMED_SURFACE' IN TYPEOF
(s.segments[i][j].parent_surface))) THEN
RETURN(FALSE);
END_IF;
END_REPEAT;
END_REPEAT;
(* Check the transition codes, omitting the last row or column *)
REPEAT i := 1 TO s.n_u-1;
REPEAT j := 1 TO s.n_v;
IF s.segments[i][j].u_transition = discontinuous THEN
RETURN(FALSE);
END_IF;
END_REPEAT;
END_REPEAT;
REPEAT i := 1 TO s.n_u;
REPEAT j := 1 TO s.n_v-1;
IF s.segments[i][j].v_transition = discontinuous THEN
RETURN(FALSE);
END_IF;
END_REPEAT;
END_REPEAT;
RETURN(TRUE);
END_FUNCTION;
FUNCTION constraints_scaling
(factors : LIST[0:?] OF REAL) : BOOLEAN;
LOCAL
result : BOOLEAN := TRUE;
END_LOCAL;
REPEAT i := 1 TO SIZEOF(factors);
IF NOT({0.0 < factors[i] <= 1.0}) THEN
result := FALSE;
RETURN(result);
END_IF;
END_REPEAT;
RETURN(result);
END_FUNCTION;
FUNCTION cross_product
(arg1 : direction; arg2 : direction) : vector;
LOCAL
mag : REAL;
res : direction;
v1,v2 : LIST[3:3] OF REAL;
result : vector;
END_LOCAL;
IF ( NOT EXISTS (arg1) OR (arg1.dim = 2)) OR
( NOT EXISTS (arg2) OR (arg2.dim = 2)) THEN
RETURN(?);
ELSE
BEGIN
v1 := normalise(arg1).direction_ratios;
v2 := normalise(arg2).direction_ratios;
res := dummy_gri || direction([(v1[2]*v2[3] - v1[3]*v2[2]),
(v1[3]*v2[1] - v1[1]*v2[3]), (v1[1]*v2[2] - v1[2]*v2[1])]);
mag := 0.0;
REPEAT i := 1 TO 3;
mag := mag + res.direction_ratios[i]*res.direction_ratios[i];
END_REPEAT;
IF (mag > 0.0) THEN
result := dummy_gri || vector(res, SQRT(mag));
ELSE
result := dummy_gri || vector(arg1, 0.0);
END_IF;
RETURN(result);
END;
END_IF;
END_FUNCTION;
FUNCTION curve_weights_positive
(b : rational_b_spline_curve) : BOOLEAN;
LOCAL
result : BOOLEAN := TRUE;
END_LOCAL;
REPEAT i := 0 TO b.upper_index_on_control_points;
IF b.weights[i] <= 0.0 THEN
result := FALSE;
RETURN(result);
END_IF;
END_REPEAT;
RETURN(result);
END_FUNCTION;
FUNCTION default_b_spline_curve_weights
(up_cp : INTEGER) : ARRAY[0:up_cp] OF REAL;
RETURN([1:up_cp + 1]);
END_FUNCTION;
FUNCTION default_b_spline_knot_mult
(degree : INTEGER; up_knots : INTEGER; uniform : knot_type) : LIST[2:?] OF INTEGER;
LOCAL
knot_mult : LIST [1:up_knots] OF INTEGER;
END_LOCAL;
IF uniform = uniform_knots THEN
knot_mult := [1:up_knots];
ELSE
IF uniform = quasi_uniform_knots THEN
knot_mult := [1:up_knots];
knot_mult[1] := degree + 1;
knot_mult[up_knots] := degree + 1;
ELSE
IF uniform = piecewise_bezier_knots THEN
knot_mult := [degree:up_knots];
knot_mult[1] := degree + 1;
knot_mult[up_knots] := degree + 1;
ELSE
knot_mult := [0:up_knots];
END_IF;
END_IF;
END_IF;
RETURN(knot_mult);
END_FUNCTION;
FUNCTION default_b_spline_knots
(degree : INTEGER; up_knots : INTEGER; uniform : knot_type) : LIST[2:?] OF parameter_value;
LOCAL
knots : LIST [1:up_knots] OF parameter_value := [0:up_knots];
ishift : INTEGER := 1;
END_LOCAL;
IF (uniform = uniform_knots) THEN
ishift := degree + 1;
END_if;
IF (uniform = uniform_knots) OR
(uniform = quasi_uniform_knots) OR
(uniform = piecewise_bezier_knots) THEN
REPEAT i := 1 TO up_knots;
knots[i] := i - ishift;
END_REPEAT;
END_IF;
RETURN(knots);
END_FUNCTION;
FUNCTION default_b_spline_surface_weights
(u_upper : INTEGER; v_upper : INTEGER) : ARRAY[0:u_upper] OF ARRAY[0:v_upper] OF REAL;
RETURN([[1:v_upper + 1]:u_upper +1]);
END_FUNCTION;
FUNCTION dimension_of
(item : geometric_representation_item) : dimension_count;
LOCAL
x : SET OF representation;
y : representation_context;
dim : dimension_count;
END_LOCAL;
-- For cartesian_point, direction, or vector dimension is determined by
-- counting components.
IF 'GEOMETRY_SCHEMA.CARTESIAN_POINT' IN TYPEOF(item) THEN
dim := SIZEOF(item\cartesian_point.coordinates);
RETURN(dim);
END_IF;
IF 'GEOMETRY_SCHEMA.DIRECTION' IN TYPEOF(item) THEN
dim := SIZEOF(item\direction.direction_ratios);
RETURN(dim);
END_IF;
IF 'GEOMETRY_SCHEMA.VECTOR' IN TYPEOF(item) THEN
dim := SIZEOF(item\vector.orientation\direction.direction_ratios);
RETURN(dim);
END_IF;
-- For all other types of geometric_representation_item dim is obtained
-- via context.
-- Find the set of representation in which the item is used.
x := using_representations(item);
-- Determines the dimension_count of the
-- geometric_representation_context.
-- The SET x is non-empty for legal instances since this is required by WR1 of
-- representation_item.
IF (SIZEOF(x) > 0) THEN
y := x[1].context_of_items;
dim := y\geometric_representation_context.coordinate_space_dimension;
RETURN (dim);
ELSE
RETURN(?);
-- mark error by returning indeterminate result
END_IF;
END_FUNCTION;
FUNCTION dot_product
(arg1 : direction; arg2 : direction) : REAL;
LOCAL
scalar : REAL;
vec1, vec2: direction;
ndim : INTEGER;
END_LOCAL;
IF NOT EXISTS (arg1) OR NOT EXISTS (arg2) THEN
scalar := ?;
(* When function is called with invalid data an indeterminate result
is returned *)
ELSE
IF (arg1.dim <> arg2.dim) THEN
scalar := ?;
(* When function is called with invalid data an indeterminate result
is returned *)
ELSE
BEGIN
vec1 := normalise(arg1);
vec2 := normalise(arg2);
ndim := arg1.dim;
scalar := 0.0;
REPEAT i := 1 TO ndim;
scalar := scalar +
vec1.direction_ratios[i]*vec2.direction_ratios[i];
END_REPEAT;
END;
END_IF;
END_IF;
RETURN (scalar);
END_FUNCTION;
FUNCTION first_proj_axis
(z_axis : direction; arg : direction) : direction;
LOCAL
x_axis : direction;
v : direction;
z : direction;
x_vec : vector;
END_LOCAL;
IF (NOT EXISTS(z_axis)) THEN
RETURN (?) ;
ELSE
z := normalise(z_axis);
IF NOT EXISTS(arg) THEN
IF ((z.direction_ratios <> [1.0,0.0,0.0]) AND
(z.direction_ratios <> [-1.0,0.0,0.0])) THEN
v := dummy_gri || direction([1.0,0.0,0.0]);
ELSE
v := dummy_gri || direction([0.0,1.0,0.0]);
END_IF;
ELSE
IF (arg.dim <> 3) THEN
RETURN (?) ;
END_IF;
IF ((cross_product(arg,z).magnitude) = 0.0) THEN
RETURN (?);
ELSE
v := normalise(arg);
END_IF;
END_IF;
x_vec := scalar_times_vector(dot_product(v, z), z);
x_axis := vector_difference(v, x_vec).orientation;
x_axis := normalise(x_axis);
END_IF;
RETURN(x_axis);
END_FUNCTION;
FUNCTION geometric_dimensionalities_in_contexts
(grcs : SET[1:?] OF geometric_representation_context) : INTEGER;
LOCAL
grcs_1d : INTEGER := 0;
grcs_2d : INTEGER := 0;
grcs_3d : INTEGER := 0;
END_LOCAL;
IF (SIZEOF(grcs) = 1) THEN
(* only one geometric_context, will be one type of dimension anyway *)
RETURN(grcs[1]\geometric_representation_context.coordinate_space_dimension);
ELSE
REPEAT i := 1 TO HIINDEX(grcs);
IF (grcs[i]\geometric_representation_context.coordinate_space_dimension = 1) THEN
grcs_1d := grcs_1d + 1;
ELSE
IF (grcs[i]\geometric_representation_context.coordinate_space_dimension = 2) THEN
grcs_2d := grcs_2d + 1;
ELSE
IF (grcs[i]\geometric_representation_context.coordinate_space_dimension = 3) THEN
grcs_3d := grcs_3d + 1;
END_IF;
END_IF;
END_IF;
END_REPEAT;
END_IF;
IF (grcs_1d + grcs_2d = 0) THEN
RETURN(3);
ELSE
IF (grcs_1d + grcs_3d = 0) THEN
RETURN(2);
ELSE
IF (grcs_2d + grcs_3d = 0) THEN
RETURN(1);
ELSE
RETURN(0); (* multiple dimensions *)
END_IF;
END_IF;
END_IF;
END_FUNCTION;
FUNCTION get_basis_surface
(c : curve_on_surface) : SET[0:2] OF surface;
LOCAL
surfs : SET[0:2] OF surface;
n : INTEGER;
END_LOCAL;
surfs := [];
IF 'GEOMETRY_SCHEMA.PCURVE' IN TYPEOF (c) THEN
surfs := [c\pcurve.basis_surface];
ELSE
IF 'GEOMETRY_SCHEMA.SURFACE_CURVE' IN TYPEOF (c) THEN
n := SIZEOF(c\surface_curve.associated_geometry);
REPEAT i := 1 TO n;
surfs := surfs +
associated_surface(c\surface_curve.associated_geometry[i]);
END_REPEAT;
END_IF;
END_IF;
IF 'GEOMETRY_SCHEMA.COMPOSITE_CURVE_ON_SURFACE' IN TYPEOF (c) THEN
(* For a composite_curve_on_surface the basis_surface is the intersection
of the basis_surfaces of all the segments. *)
n := SIZEOF(c\composite_curve.segments);
surfs := get_basis_surface(
c\composite_curve.segments[1].parent_curve);
IF n > 1 THEN
REPEAT i := 2 TO n;
surfs := surfs * get_basis_surface(
c\composite_curve.segments[i].parent_curve);
END_REPEAT;
END_IF;
END_IF;
RETURN(surfs);
END_FUNCTION;
FUNCTION increasing_values_in_list
(values : LIST[2:?] OF REAL) : BOOLEAN;
LOCAL result : BOOLEAN := TRUE; limit : INTEGER := SIZEOF(values); END_LOCAL; REPEAT i := 2 TO limit; IF values[i] <= values[i-1] THEN result := FALSE; END_IF; END_REPEAT; RETURN(result);
END_FUNCTION;
FUNCTION list_to_array
(lis : LIST[0:?] OF GENERIC : T; low : INTEGER; u : INTEGER) : ARRAY[low:u] OF GENERIC : T;
LOCAL
n : INTEGER;
res : ARRAY [low:u] OF GENERIC : T;
END_LOCAL;
n := SIZEOF(lis);
IF (n <> (u-low +1)) THEN
RETURN(?);
ELSE
res := [lis[1] : n];
REPEAT i := 2 TO n;
res[low+i-1] := lis[i];
END_REPEAT;
RETURN(res);
END_IF;
END_FUNCTION;
FUNCTION make_array_of_array
(lis : LIST[1:?] OF LIST[1:?] OF GENERIC : T; low1 : INTEGER; u1 : INTEGER; low2 : INTEGER; u2 : INTEGER) : ARRAY[low1:u1] OF ARRAY[low2:u2] OF GENERIC : T;
LOCAL
res : ARRAY[low1:u1] OF ARRAY [low2:u2] OF GENERIC : T;
END_LOCAL;
(* Check input dimensions for consistency *)
IF (u1-low1+1) <> SIZEOF(lis) THEN
RETURN (?);
END_IF;
IF (u2 - low2 + 1 ) <> SIZEOF(lis[1]) THEN
RETURN (?) ;
END_IF;
(* Initialise res with values from lis[1] *)
res := [list_to_array(lis[1], low2, u2) : (u1-low1 + 1)];
REPEAT i := 2 TO HIINDEX(lis);
IF (u2-low2+1) <> SIZEOF(lis[i]) THEN
RETURN (?);
END_IF;
res[low1+i-1] := list_to_array(lis[i], low2, u2);
END_REPEAT;
RETURN (res);
END_FUNCTION;
FUNCTION make_array_of_array_of_array
(lis : LIST[1:?] OF LIST[1:?] OF LIST[1:?] OF GENERIC : T; low1 : INTEGER; u1 : INTEGER; low2 : INTEGER; u2 : INTEGER; low3 : INTEGER; u3 : INTEGER) : ARRAY[low1:u1] OF ARRAY[low2:u2] OF ARRAY[low3:u3] OF GENERIC : T;
LOCAL
res : ARRAY[low1:u1] OF ARRAY [low2:u2] OF
ARRAY[low3:u3] OF GENERIC : T;
END_LOCAL;
(* Check input dimensions for consistency *)
IF (u1-low1+1) <> SIZEOF(lis) THEN
RETURN (?);
END_IF;
IF (u2-low2+1) <> SIZEOF(lis[1]) THEN
RETURN (?);
END_IF;
(* Initialise res with values from lis[1] *)
res := [make_array_of_array(lis[1], low2, u2, low3, u3) : (u1-low1 + 1)];
REPEAT i := 2 TO HIINDEX(lis);
IF (u2-low2+1) <> SIZEOF(lis[i]) THEN
RETURN (?);
END_IF;
res[low1+i-1] := make_array_of_array(lis[i], low2, u2, low3, u3);
END_REPEAT;
RETURN (res);
END_FUNCTION;
FUNCTION normalise
(arg : vector_or_direction) : vector_or_direction;
LOCAL
ndim : INTEGER;
v : direction := dummy_gri || direction ([1.0,0.0,0.0]);
result : vector_or_direction;
vec : vector := dummy_gri || vector (v, 1.0);
mag : REAL;
END_LOCAL;
IF NOT EXISTS (arg) THEN
result := ?;
(* When function is called with invalid data a NULL result is returned *)
ELSE
ndim := arg.dim;
IF 'GEOMETRY_SCHEMA.VECTOR' IN TYPEOF(arg) THEN
BEGIN
v := dummy_gri || direction(arg\vector.orientation.direction_ratios);
IF arg\vector.magnitude = 0.0 THEN
RETURN(?);
ELSE
vec := dummy_gri || vector (v, 1.0);
END_IF;
END;
ELSE
v := dummy_gri || direction (arg.direction_ratios);
END_IF;
mag := 0.0;
REPEAT i := 1 TO ndim;
mag := mag + v.direction_ratios[i]*v.direction_ratios[i];
END_REPEAT;
IF mag > 0.0 THEN
mag := SQRT(mag);
REPEAT i := 1 TO ndim;
v.direction_ratios[i] := v.direction_ratios[i]/mag;
END_REPEAT;
IF 'GEOMETRY_SCHEMA.VECTOR' IN TYPEOF(arg) THEN
vec.orientation := v;
result := vec;
ELSE
result := v;
END_IF;
ELSE
RETURN(?);
END_IF;
END_IF;
RETURN (result);
END_FUNCTION;
FUNCTION orthogonal_complement
(vec : direction) : direction;
LOCAL
result : direction ;
END_LOCAL;
IF (vec.dim <> 2) OR NOT EXISTS (vec) THEN
RETURN(?);
ELSE
result := dummy_gri || direction([-vec.direction_ratios[2],
vec.direction_ratios[1]]);
RETURN(result);
END_IF;
END_FUNCTION;
FUNCTION same_side
(plane_pts : LIST[3:3] OF cartesian_point; test_points : LIST[2:?] OF cartesian_point) : BOOLEAN;
LOCAL
val1, val2 : REAL;
n : INTEGER;
END_LOCAL;
IF (plane_pts[1].dim = 2) OR (test_points[1].dim = 2) THEN
RETURN(?);
END_IF;
n := SIZEOF(test_points);
val1 := above_plane(plane_pts[1], plane_pts[2], plane_pts[3],
test_points[1] );
REPEAT i := 2 TO n;
val2 := above_plane(plane_pts[1], plane_pts[2], plane_pts[3],
test_points[i] );
IF (val1*val2 <= 0.0) THEN
RETURN(FALSE);
END_IF;
END_REPEAT;
RETURN(TRUE);
END_FUNCTION;
FUNCTION scalar_times_vector
(scalar : REAL; vec : vector_or_direction) : vector;
LOCAL
v : direction;
mag : REAL;
result : vector;
END_LOCAL;
IF NOT EXISTS (scalar) OR NOT EXISTS (vec) THEN
RETURN (?) ;
ELSE
IF 'GEOMETRY_SCHEMA.VECTOR' IN TYPEOF (vec) THEN
v := dummy_gri || direction(vec\vector.orientation.direction_ratios);
mag := scalar * vec\vector.magnitude;
ELSE
v := dummy_gri || direction(vec.direction_ratios);
mag := scalar;
END_IF;
IF (mag < 0.0 ) THEN
REPEAT i := 1 TO SIZEOF(v.direction_ratios);
v.direction_ratios[i] := -v.direction_ratios[i];
END_REPEAT;
mag := -mag;
END_IF;
result := dummy_gri || vector(normalise(v), mag);
END_IF;
RETURN (result);
END_FUNCTION;
FUNCTION second_proj_axis
(z_axis : direction; x_axis : direction; arg : direction) : direction;
LOCAL
y_axis : vector;
v : direction;
temp : vector;
END_LOCAL;
IF NOT EXISTS(arg) THEN
v := dummy_gri || direction([0.0,1.0,0.0]);
ELSE
v := arg;
END_IF;
temp := scalar_times_vector(dot_product(v, z_axis), z_axis);
y_axis := vector_difference(v, temp);
temp := scalar_times_vector(dot_product(v, x_axis), x_axis);
y_axis := vector_difference(y_axis, temp);
y_axis := normalise(y_axis);
RETURN(y_axis.orientation);
END_FUNCTION;
FUNCTION surface_weights_positive
(b : rational_b_spline_surface) : BOOLEAN;
LOCAL
result : BOOLEAN := TRUE;
END_LOCAL;
REPEAT i := 0 TO b.u_upper;
REPEAT j := 0 TO b.v_upper;
IF (b.weights[i][j] <= 0.0) THEN
result := FALSE;
RETURN(result);
END_IF;
END_REPEAT;
END_REPEAT;
RETURN(result);
END_FUNCTION;
FUNCTION vector_difference
(arg1 : vector_or_direction; arg2 : vector_or_direction) : vector;
LOCAL
result : vector;
res, vec1, vec2 : direction;
mag, mag1, mag2 : REAL;
ndim : INTEGER;
END_LOCAL;
IF ((NOT EXISTS (arg1)) OR (NOT EXISTS (arg2))) OR (arg1.dim <> arg2.dim)
THEN
RETURN (?) ;
ELSE
BEGIN
IF 'GEOMETRY_SCHEMA.VECTOR' IN TYPEOF(arg1) THEN
mag1 := arg1\vector.magnitude;
vec1 := arg1\vector.orientation;
ELSE
mag1 := 1.0;
vec1 := arg1;
END_IF;
IF 'GEOMETRY_SCHEMA.VECTOR' IN TYPEOF(arg2) THEN
mag2 := arg2\vector.magnitude;
vec2 := arg2\vector.orientation;
ELSE
mag2 := 1.0;
vec2 := arg2;
END_IF;
vec1 := normalise (vec1);
vec2 := normalise (vec2);
ndim := SIZEOF(vec1.direction_ratios);
mag := 0.0;
res := dummy_gri || direction(vec1.direction_ratios);
REPEAT i := 1 TO ndim;
res.direction_ratios[i] := mag1*vec1.direction_ratios[i] -
mag2*vec2.direction_ratios[i];
mag := mag + (res.direction_ratios[i]*res.direction_ratios[i]);
END_REPEAT;
IF (mag > 0.0 ) THEN
result := dummy_gri || vector( res, SQRT(mag));
ELSE
result := dummy_gri || vector( vec1, 0.0);
END_IF;
END;
END_IF;
RETURN (result);
END_FUNCTION;
FUNCTION vector_sum
(arg1 : vector_or_direction; arg2 : vector_or_direction) : vector;
LOCAL
result : vector;
res, vec1, vec2 : direction;
mag, mag1, mag2 : REAL;
ndim : INTEGER;
END_LOCAL;
IF ((NOT EXISTS (arg1)) OR (NOT EXISTS (arg2))) OR (arg1.dim <> arg2.dim)
THEN
RETURN (?) ;
ELSE
BEGIN
IF 'GEOMETRY_SCHEMA.VECTOR' IN TYPEOF(arg1) THEN
mag1 := arg1\vector.magnitude;
vec1 := arg1\vector.orientation;
ELSE
mag1 := 1.0;
vec1 := arg1;
END_IF;
IF 'GEOMETRY_SCHEMA.VECTOR' IN TYPEOF(arg2) THEN
mag2 := arg2\vector.magnitude;
vec2 := arg2\vector.orientation;
ELSE
mag2 := 1.0;
vec2 := arg2;
END_IF;
vec1 := normalise (vec1);
vec2 := normalise (vec2);
ndim := SIZEOF(vec1.direction_ratios);
mag := 0.0;
res := dummy_gri || direction(vec1.direction_ratios);
REPEAT i := 1 TO ndim;
res.direction_ratios[i] := mag1*vec1.direction_ratios[i] +
mag2*vec2.direction_ratios[i];
mag := mag + (res.direction_ratios[i]*res.direction_ratios[i]);
END_REPEAT;
IF (mag > 0.0 ) THEN
result := dummy_gri || vector( res, SQRT(mag));
ELSE
result := dummy_gri || vector( vec1, 0.0);
END_IF;
END;
END_IF;
RETURN (result);
END_FUNCTION;
FUNCTION volume_weights_positive
(b : rational_b_spline_volume) : BOOLEAN;
LOCAL
result : BOOLEAN := TRUE;
END_LOCAL;
REPEAT i := 0 TO b.u_upper;
REPEAT j := 0 TO b.v_upper;
REPEAT k := 0 TO b.w_upper;
IF (b.weights[i][j][k] <= 0.0) THEN
result := FALSE;
RETURN(result);
END_IF;
END_REPEAT;
END_REPEAT;
END_REPEAT;
RETURN(result);
END_FUNCTION;
FUNCTION weights_positive
(weights : LIST[0:?] OF REAL) : BOOLEAN;
LOCAL result : BOOLEAN := TRUE; END_LOCAL; REPEAT i := 1 TO SIZEOF(weights); IF weights[i] <= 0.0 THEN result := FALSE; RETURN(result); END_IF; END_REPEAT; RETURN(result);
END_FUNCTION;
END_SCHEMA; -- geometry_schema
© ISO 2021 — All rights reserved