ISO 10303-42:2021(E)


Integrated generic resource: Geometric and topological representation	ISO 10303-42:2021(E) © ISO

Cover page
Table of contents
Copyright
Foreword
Introduction
1 Scope
2 Normative references
3 Terms, definitions and abbreviated terms
3.1 Terms and definitions
3.2 Abbreviated terms

4 Geometry
4.1 General
4.2 Fundamental concepts and assumptions
4.3 Geometry constant definition
4.4 Geometry type definitions
4.5 Geometry entity definitions
4.6 Geometry function definitions
4.7 Geometry rule definitions
5 Topology
5.1 General
5.2 Fundamental concepts and assumptions
5.3 Topology constant definition
5.4 Topology type definitions
5.5 Topology entity definitions
5.6 Topology function definitions
6 Geometric model
6.1 General
6.2 Fundamental concepts and assumptions
6.3 Geometric model type definitions
6.4 Geometric model entity definitions
6.5 Geometric model function definitions
7 Scan data 3d shape model
7.1 General
7.2 Fundamental concepts and assumptions
7.3 Scan data 3d shape model type definition
7.4 Scan data 3d shape model entity definitions
7.5 Scan data 3d shape model function definitions

A Short names of entities
B Information object registration
C Computer interpretable listings
D EXPRESS-G diagrams
E Change history
Bibliography
Index


         (*
ISO/TC 184/SC 4/WG 12 N10888 - ISO 10303-42 Geometric and topological representation - EXPRESS
Supersedes 
         ISO/TC 184/SC 4/WG 12 N9792
*)




            SCHEMA geometric_model_schema;


         REFERENCE FROM 
         geometry_schema;
            -- ISO 10303-42


         REFERENCE FROM 
         topology_schema;
            -- ISO 10303-42


         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,

           
         ratio_measure);


         REFERENCE FROM 
         representation_schema   -- ISO 10303-43
  (founded_item,

           
         representation,

           
         representation_item,

           
         using_representations);


         REFERENCE FROM 
         product_property_representation_schema   -- ISO 10303-41
  (shape_representation);


TYPE angular_deviation =
         positive_plane_angle_measure;

         END_TYPE;


TYPE boolean_operand =
         
         
         SELECT

            (boolean_result, 
    csg_primitive, 
    half_space_2d, 
    half_space_solid, 
    solid_model);

         END_TYPE;


TYPE boolean_operator =
         
         ENUMERATION
         
         OF
         

            
         (union,
    intersection,
    difference);

         END_TYPE;


TYPE bounded_primitive_2d =
         
         EXTENSIBLE
         
         GENERIC_ENTITY
         
         
         SELECT

            (area_with_outer_boundary, 
    circular_area, 
    elliptic_area, 
    polygonal_area, 
    rectangular_area);

         END_TYPE;


TYPE chordal_deviation =
         positive_length_measure;

         END_TYPE;


TYPE csg_primitive =
         
         
         SELECT

            (block, 
    bounded_primitive_2d, 
    cyclide_segment_solid, 
    eccentric_cone, 
    ellipsoid, 
    faceted_primitive, 
    rectangular_pyramid, 
    right_angular_wedge, 
    right_circular_cone, 
    right_circular_cylinder, 
    sphere, 
    torus);

         END_TYPE;


TYPE csg_select =
         
         
         SELECT

            (boolean_result, 
    csg_primitive);

         END_TYPE;


TYPE edge_or_curve =
         
         
         SELECT

            (curve, 
    edge_curve);

         END_TYPE;


TYPE face_or_surface =
         
         
         SELECT

            (face_surface, 
    surface);

         END_TYPE;


TYPE geometric_set_select =
         
         EXTENSIBLE
         
         GENERIC_ENTITY
         
         
         SELECT

            (curve, 
    point, 
    surface);

         END_TYPE;


TYPE length_to_height_ratio =
         ratio_measure;

         END_TYPE;


TYPE maximum_edge_length =
         positive_length_measure;

         END_TYPE;


TYPE path_or_composite_curve =
         
         
         SELECT

            (composite_curve, 
    path);

         END_TYPE;


TYPE surface_model =
         
         
         SELECT

            (face_based_surface_model, 
    shell_based_surface_model);

         END_TYPE;


TYPE tessellated_facet_long_short_edge_ratio =
         ratio_measure;

         END_TYPE;


TYPE tessellated_edge_or_vertex =
         
         
         SELECT

            (tessellated_edge, 
    tessellated_vertex);

         END_TYPE;


TYPE tessellation_accuracy_parameter_item =
         
         EXTENSIBLE
         
         
         SELECT

            (angular_deviation, 
    chordal_deviation, 
    length_to_height_ratio, 
    maximum_edge_length, 
    tessellated_facet_long_short_edge_ratio);

         END_TYPE;


TYPE wireframe_model =
         
         
         SELECT

            (edge_based_wireframe_model, 
    shell_based_wireframe_model);

         END_TYPE;


ENTITY solid_model

           SUPERTYPE OF 
         (ONEOF (csg_solid,
                       manifold_solid_brep,
                       swept_face_solid,
                       swept_area_solid,
                       swept_disk_solid,
                       solid_replica,
                       brep_2d,
                       trimmed_volume))

           SUBTYPE OF (geometric_representation_item);

         
         END_ENTITY;


ENTITY manifold_solid_brep

           SUBTYPE OF (solid_model);

           outer : closed_shell;

         
         END_ENTITY;


ENTITY brep_with_voids

           SUBTYPE OF (manifold_solid_brep);

           voids : SET[1:?] OF oriented_closed_shell;

         
         END_ENTITY;


ENTITY faceted_brep

           SUBTYPE OF (manifold_solid_brep);

         
         END_ENTITY;


ENTITY brep_2d

           SUBTYPE OF (solid_model);

           extent : face;
WHERE

           WR1: SIZEOF (['TOPOLOGY_SCHEMA.FACE_SURFACE', 'TOPOLOGY_SCHEMA.SUBFACE', 'TOPOLOGY_SCHEMA.ORIENTED_FACE'] * TYPEOF (SELF.extent))
            = 0;

           WR2: SIZEOF (QUERY (bnds <* extent.bounds | NOT ('TOPOLOGY_SCHEMA.EDGE_LOOP' IN TYPEOF(bnds.bound))) ) = 0;

           WR3: SIZEOF (QUERY (bnds <* extent.bounds | 'TOPOLOGY_SCHEMA.FACE_OUTER_BOUND' IN TYPEOF(bnds))) = 1;

           WR4: SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* extent.bounds | 'TOPOLOGY_SCHEMA.EDGE_LOOP' IN TYPEOF(bnds.bound)) | NOT (SIZEOF
            (QUERY (oe <* elp_fbnds.bound\path.edge_list | NOT (('TOPOLOGY_SCHEMA.EDGE_CURVE' IN TYPEOF(oe.edge_element)) AND (oe.edge_element\geometric_representation_item.dim
            = 2)))) = 0))) = 0;

         
         END_ENTITY;


ENTITY csg_solid

           SUBTYPE OF (solid_model);

           tree_root_expression : csg_select;

         
         END_ENTITY;


ENTITY boolean_result

           SUBTYPE OF (geometric_representation_item);

           operator : boolean_operator;

           first_operand : boolean_operand;

           second_operand : boolean_operand;

         
         END_ENTITY;


ENTITY block

           SUBTYPE OF (geometric_representation_item);

           position : axis2_placement_3d;

           x : positive_length_measure;

           y : positive_length_measure;

           z : positive_length_measure;

         
         END_ENTITY;


ENTITY right_angular_wedge

           SUBTYPE OF (geometric_representation_item);

           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 rectangular_pyramid

           SUBTYPE OF (geometric_representation_item);

           position : axis2_placement_3d;

           xlength : positive_length_measure;

           ylength : positive_length_measure;

           height : positive_length_measure;

         
         END_ENTITY;


ENTITY faceted_primitive

           SUPERTYPE OF 
         (ONEOF (tetrahedron,
                       convex_hexahedron))

           SUBTYPE OF (geometric_representation_item);

           points : LIST[4:?] OF 
         UNIQUE
         cartesian_point;
WHERE

           WR1: points[1].dim = 3;

         
         END_ENTITY;


ENTITY tetrahedron

           SUBTYPE OF (faceted_primitive);
WHERE

           WR1: SIZEOF(points) = 4;

           WR2: above_plane(points[1], points[2], points[3], points[4]) <> 0.0;

         
         END_ENTITY;


ENTITY convex_hexahedron

           SUBTYPE OF (faceted_primitive);
WHERE

           WR1: SIZEOF(points) = 8;

           WR2: above_plane(points[1], points[2], points[3], points[4]) = 0.0;

           WR3: above_plane(points[5], points[8], points[7], points[6]) = 0.0;

           WR4: above_plane(points[1], points[4], points[8], points[5]) = 0.0;

           WR5: above_plane(points[4], points[3], points[7], points[8]) = 0.0;

           WR6: above_plane(points[3], points[2], points[6], points[7]) = 0.0;

           WR7: above_plane(points[1], points[5], points[6], points[2]) = 0.0;

           WR8: same_side([points[1], points[2], points[3]], [points[5], points[6], points[7], points[8]]);

           WR9: same_side([points[1], points[4], points[8]], [points[3], points[7], points[6], points[2]]);

           WR10: same_side([points[1], points[2], points[5]], [points[3], points[7], points[8], points[4]]);

           WR11: same_side([points[5], points[6], points[7]], [points[1], points[2], points[3], points[4]]);

           WR12: same_side([points[3], points[7], points[6]], [points[1], points[4], points[8], points[5]]);

           WR13: same_side([points[3], points[7], points[8]], [points[1], points[5], points[6], points[2]]);

         
         END_ENTITY;


ENTITY sphere

           SUBTYPE OF (geometric_representation_item);

           radius : positive_length_measure;

           centre : point;

         
         END_ENTITY;


ENTITY right_circular_cone

           SUBTYPE OF (geometric_representation_item);

           position : axis1_placement;

           height : positive_length_measure;

           radius : length_measure;

           semi_angle : plane_angle_measure;
WHERE

           WR1: radius >= 0.0;

         
         END_ENTITY;


ENTITY right_circular_cylinder

           SUBTYPE OF (geometric_representation_item);

           position : axis1_placement;

           height : positive_length_measure;

           radius : positive_length_measure;

         
         END_ENTITY;


ENTITY eccentric_cone

           SUBTYPE OF (geometric_representation_item);

           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 torus

           SUBTYPE OF (geometric_representation_item);

           position : axis1_placement;

           major_radius : positive_length_measure;

           minor_radius : positive_length_measure;
WHERE

           WR1: major_radius > minor_radius;

         
         END_ENTITY;


ENTITY ellipsoid

           SUBTYPE OF (geometric_representation_item);

           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 cyclide_segment_solid

           SUBTYPE OF (geometric_representation_item);

           position : axis2_placement_3d;

           radius1 : positive_length_measure;

           radius2 : positive_length_measure;

           cone_angle1 : plane_angle_measure;

           cone_angle2 : plane_angle_measure;

           turn_angle : plane_angle_measure;

         
         END_ENTITY;


ENTITY half_space_solid

           SUBTYPE OF (geometric_representation_item);

           base_surface : surface;

           agreement_flag : BOOLEAN;

         
         END_ENTITY;


ENTITY boxed_half_space

           SUBTYPE OF (half_space_solid);

           enclosure : box_domain;

         
         END_ENTITY;


ENTITY box_domain

           SUBTYPE OF (founded_item);

           corner : cartesian_point;

           xlength : positive_length_measure;

           ylength : positive_length_measure;

           zlength : positive_length_measure;
WHERE

           WR1: SIZEOF(QUERY(item <* USEDIN(SELF,'')| NOT ('GEOMETRIC_MODEL_SCHEMA.BOXED_HALF_SPACE' IN TYPEOF(item)))) = 0;

         
         END_ENTITY;


ENTITY primitive_2d

           SUPERTYPE OF 
         (ONEOF (circular_area,
                       elliptic_area,
                       rectangular_area,
                       polygonal_area,
                       half_space_2d))

           SUBTYPE OF (geometric_representation_item);
WHERE

           WR1: SELF\geometric_representation_item.dim = 2;

         
         END_ENTITY;


ENTITY circular_area

           SUBTYPE OF (primitive_2d);

           centre : cartesian_point;

           radius : positive_length_measure;

         
         END_ENTITY;


ENTITY elliptic_area

           SUBTYPE OF (primitive_2d);

           position : axis2_placement_2d;

           semi_axis_1 : positive_length_measure;

           semi_axis_2 : positive_length_measure;

         
         END_ENTITY;


ENTITY rectangular_area

           SUBTYPE OF (primitive_2d);

           position : axis2_placement_2d;

           x : positive_length_measure;

           y : positive_length_measure;

         
         END_ENTITY;


ENTITY polygonal_area

           SUBTYPE OF (primitive_2d);

           bounds : LIST[3:?] OF 
         UNIQUE
         cartesian_point;

         
         END_ENTITY;


ENTITY area_with_outer_boundary

           SUBTYPE OF (half_space_2d);

           SELF\half_space_2d.base_curve : composite_curve;
WHERE

           WR1: base_curve\composite_curve.closed_curve = TRUE;

         
         END_ENTITY;


ENTITY half_space_2d

           SUBTYPE OF (primitive_2d);

           base_curve : curve;

           agreement_flag : BOOLEAN;

         
         END_ENTITY;


ENTITY rectangled_half_space

           SUBTYPE OF (half_space_2d);

           enclosure : rectangle_domain;

         
         END_ENTITY;


ENTITY rectangle_domain

           SUBTYPE OF (founded_item);

           corner : cartesian_point;

           xlength : positive_length_measure;

           ylength : positive_length_measure;
WHERE

           WR1: SIZEOF(QUERY(item <* USEDIN(SELF, '')| NOT ('GEOMETRIC_MODEL_SCHEMA.RECTANGLED_HALF_SPACE' IN TYPEOF(item)))) = 0;

         
         END_ENTITY;


ENTITY swept_face_solid

           SUPERTYPE OF 
         (ONEOF (extruded_face_solid,
                       revolved_face_solid,
                       surface_curve_swept_face_solid))

           SUBTYPE OF (solid_model);

           swept_face : face_surface;
WHERE

           WR1: 'GEOMETRY_SCHEMA.PLANE' IN TYPEOF(swept_face.face_geometry);

         
         END_ENTITY;


ENTITY extruded_face_solid

           SUBTYPE OF (swept_face_solid);

           extruded_direction : direction;

           depth : positive_length_measure;
WHERE

           WR1: dot_product( (SELF\swept_face_solid.swept_face.face_geometry\ elementary_surface.position.p[3]), extruded_direction)
            <> 0.0;

         
         END_ENTITY;


ENTITY revolved_face_solid

           SUBTYPE OF (swept_face_solid);

           axis : axis1_placement;

           angle : plane_angle_measure;
DERIVE

           axis_line : line := representation_item('')|| geometric_representation_item()|| curve()|| line(axis.location, representation_item('')|| geometric_representation_item()||
         vector(axis.z, 1.0));

         
         END_ENTITY;


ENTITY surface_curve_swept_face_solid

           SUBTYPE OF (swept_face_solid);

           directrix : curve;

           start_param : REAL;

           end_param : REAL;

           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 swept_area_solid

           SUPERTYPE OF 
         (ONEOF (revolved_area_solid,
                       extruded_area_solid,
                       surface_curve_swept_area_solid))

           SUBTYPE OF (solid_model);

           swept_area : curve_bounded_surface;
WHERE

           WR1: 'GEOMETRY_SCHEMA.PLANE' IN TYPEOF(swept_area.basis_surface);

         
         END_ENTITY;


ENTITY extruded_area_solid

           SUBTYPE OF (swept_area_solid);

           extruded_direction : direction;

           depth : positive_length_measure;
WHERE

           WR1: dot_product( (SELF\swept_area_solid.swept_area.basis_surface\ elementary_surface.position.p[3]), extruded_direction)
            <> 0.0;

         
         END_ENTITY;


ENTITY revolved_area_solid

           SUBTYPE OF (swept_area_solid);

           axis : axis1_placement;

           angle : plane_angle_measure;
DERIVE

           axis_line : line := representation_item('')|| geometric_representation_item()|| curve()|| line(axis.location, representation_item('')|| geometric_representation_item()||
         vector(axis.z, 1.0));

         
         END_ENTITY;


ENTITY surface_curve_swept_area_solid

           SUBTYPE OF (swept_area_solid);

           directrix : curve;

           start_param : REAL;

           end_param : REAL;

           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 swept_disk_solid

           SUBTYPE OF (solid_model);

           directrix : curve;

           radius : positive_length_measure;

           inner_radius : 
         OPTIONAL 
         positive_length_measure;

           start_param : REAL;

           end_param : REAL;
WHERE

           WR1: directrix.dim = 3;

           WR2: (NOT EXISTS(inner_radius)) OR (radius > inner_radius);

         
         END_ENTITY;


ENTITY trimmed_volume

           SUBTYPE OF (solid_model);

           basis_volume : volume;

           u1 : parameter_value;

           u2 : parameter_value;

           v1 : parameter_value;

           v2 : parameter_value;

           w1 : parameter_value;

           w2 : parameter_value;
WHERE

           WR1: u1 <> u2;

           WR2: v1 <> v2;

           WR3: w1 <> w2;

         
         END_ENTITY;


ENTITY solid_replica

           SUBTYPE OF (solid_model);

           parent_solid : solid_model;

           transformation : cartesian_transformation_operator_3d;
WHERE

           WR1: acyclic_solid_replica(SELF, parent_solid);

           WR2: parent_solid\geometric_representation_item.dim = 3;

         
         END_ENTITY;


ENTITY shell_based_surface_model

           SUBTYPE OF (geometric_representation_item);

           sbsm_boundary : SET[1:?] OF shell;
WHERE

           WR1: constraints_geometry_shell_based_surface_model(SELF);

         
         END_ENTITY;


ENTITY face_based_surface_model

           SUBTYPE OF (geometric_representation_item);

           fbsm_faces : SET[1:?] OF connected_face_set;

         
         END_ENTITY;


ENTITY shell_based_wireframe_model

           SUBTYPE OF (geometric_representation_item);

           sbwm_boundary : SET[1:?] OF shell;
WHERE

           WR1: constraints_geometry_shell_based_wireframe_model(SELF);

         
         END_ENTITY;


ENTITY edge_based_wireframe_model

           SUBTYPE OF (geometric_representation_item);

           ebwm_boundary : SET[1:?] OF connected_edge_set;

         
         END_ENTITY;


ENTITY geometric_set

           SUPERTYPE OF 
         (ONEOF (geometric_curve_set,
                       geometric_set_replica))

           SUBTYPE OF (geometric_representation_item);

           elements : SET[1:?] OF geometric_set_select;

         
         END_ENTITY;


ENTITY geometric_curve_set

           SUBTYPE OF (geometric_set);
WHERE

           WR1: SIZEOF(QUERY(temp <* SELF\geometric_set.elements |NOT (('GEOMETRY_SCHEMA.CURVE' IN TYPEOF(temp)) OR  ('GEOMETRY_SCHEMA.POINT'
            IN 
            TYPEOF(temp))) )) = 0;

         
         END_ENTITY;


ENTITY sectioned_spine

           SUBTYPE OF (geometric_curve_set);

           cross_sections : LIST[2:?] OF curve;

           spine_points : LIST[2:?] OF point;
WHERE

           WR1: SIZEOF(SELF\geometric_set.elements) = 1;

           WR2: 'GEOMETRY_SCHEMA.CURVE' IN TYPEOF(SELF\geometric_set.elements[1]);

           WR3: SIZEOF(cross_sections) = SIZEOF(spine_points);

           WR4: SELF\geometric_representation_item.dim = 3;

         
         END_ENTITY;


ENTITY geometric_set_replica

           SUBTYPE OF (geometric_set);

           parent_set : geometric_set;

           transformation : cartesian_transformation_operator;
DERIVE

           SELF\geometric_set.elements : SET[1:?] OF geometric_set_select := build_transformed_set(transformation, parent_set);
WHERE

           WR1: acyclic_set_replica(SELF, parent_set);

         
         END_ENTITY;


ENTITY tessellated_shape_representation

           SUBTYPE OF (shape_representation);
WHERE

           WR1: 'REPRESENTATION_SCHEMA.GLOBAL_UNIT_ASSIGNED_CONTEXT' IN
            TYPEOF(SELF\representation.context_of_items);

           WR2: NOT( SIZEOF(QUERY ( it <* SELF.items|   
            'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_ITEM' IN TYPEOF (it))) = 0 );

         
         END_ENTITY;


ENTITY tessellated_item

           ABSTRACT SUPERTYPE
         
         OF (ONEOF (coordinates_list,
                                tessellated_solid,
                                tessellated_shell,
                                tessellated_wire,
                                tessellated_geometric_set,
                                tessellated_curve_set,
                                tessellated_point_set,
                                tessellated_surface_set,
                                tessellated_structured_item))

           SUBTYPE OF (geometric_representation_item);
WHERE

           WR1: SIZEOF (QUERY (using_rep <* using_representations (SELF) | NOT ('GEOMETRIC_MODEL_SCHEMA.TESSELLATED_SHAPE_REPRESENTATION'
            IN TYPEOF(using_rep)))) = 0;

         
         END_ENTITY;


ENTITY repositioned_tessellated_item

           SUBTYPE OF (tessellated_item);

           location : axis2_placement_3d;
WHERE

           WR1: NOT (SIZEOF (['GEOMETRIC_MODEL_SCHEMA.TESSELLATED_CURVE_SET', 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_GEOMETRIC_SET', 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_POINT_SET',
            'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_SURFACE_SET', 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_SHELL', 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_SOLID',
            'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_WIRE'] * TYPEOF(SELF)) = 0);

         
         END_ENTITY;


ENTITY tessellated_structured_item

           SUPERTYPE OF 
         (ONEOF (tessellated_face,
                       tessellated_edge,
                       tessellated_vertex))

           SUBTYPE OF (tessellated_item);

         
         END_ENTITY;


ENTITY coordinates_list

           SUBTYPE OF (tessellated_item);

           npoints : INTEGER;

           position_coords : LIST[1:?] OF LIST[3:3] OF REAL;
WHERE

           WR1: npoints = SIZEOF(position_coords);

           WR2: SIZEOF (['GEOMETRIC_MODEL_SCHEMA.REPOSITIONED_TESSELLATED_ITEM'] * TYPEOF(SELF)) = 0;

         
         END_ENTITY;


ENTITY tessellated_vertex

           SUBTYPE OF (tessellated_structured_item);

           coordinates : coordinates_list;

           topological_link : 
         OPTIONAL 
         vertex_point;

           point_index : INTEGER;

         
         END_ENTITY;


ENTITY tessellated_edge

           SUPERTYPE OF 
         (ONEOF (tessellated_connecting_edge,
                       cubic_bezier_tessellated_edge))

           SUBTYPE OF (tessellated_structured_item);

           coordinates : coordinates_list;

           geometric_link : 
         OPTIONAL 
         edge_or_curve;

           line_strip : LIST[2:?] OF INTEGER;

         
         END_ENTITY;


ENTITY tessellated_connecting_edge

           SUBTYPE OF (tessellated_edge);

           smooth : LOGICAL;

           face1 : tessellated_face;

           face2 : tessellated_face;

           line_strip_face1 : LIST[2:?] OF INTEGER;

           line_strip_face2 : LIST[2:?] OF INTEGER;
WHERE

           WR1: SIZEOF(line_strip_face1) = SIZEOF(line_strip_face2);

           WR2: SIZEOF(line_strip_face1) = SIZEOF(SELF\tessellated_edge.line_strip);

           WR3: NOT(('GEOMETRIC_MODEL_SCHEMA.CUBIC_BEZIER_TRIANGULATED_FACE') IN TYPEOF(face1));

           WR4: NOT(('GEOMETRIC_MODEL_SCHEMA.CUBIC_BEZIER_TRIANGULATED_FACE') IN TYPEOF(face2));

         
         END_ENTITY;


ENTITY tessellated_face

           ABSTRACT SUPERTYPE
         
         OF (ONEOF (triangulated_face,
                                complex_triangulated_face,
                                cubic_bezier_triangulated_face))

           SUBTYPE OF (tessellated_structured_item);

           coordinates : coordinates_list;

           pnmax : INTEGER;

           normals : LIST[0:?] OF LIST[3:3] OF REAL;

           geometric_link : 
         OPTIONAL 
         face_or_surface;
WHERE

           WR1: ((SIZEOF(normals) = 0) OR (SIZEOF(normals) = 1) OR (SIZEOF(normals) = pnmax));

         
         END_ENTITY;


ENTITY triangulated_face

           SUBTYPE OF (tessellated_face);

           pnindex : LIST[0:?] OF INTEGER;

           triangles : LIST[1:?] OF LIST[3:3] OF INTEGER;
WHERE

           WR1: ((SIZEOF(pnindex) = 0) OR (SIZEOF(pnindex) = SELF\tessellated_face.pnmax));

           WR2: NOT((SIZEOF(pnindex) = 0) AND (SELF\tessellated_face.pnmax <> coordinates.npoints));

         
         END_ENTITY;


ENTITY cubic_bezier_tessellated_edge

           SUBTYPE OF (tessellated_edge);

           SELF\tessellated_edge.line_strip : LIST[4:?] OF INTEGER;

         
         END_ENTITY;


ENTITY cubic_tessellated_connecting_edge

           SUBTYPE OF (cubic_bezier_tessellated_edge);

           smooth : LOGICAL;

           face1 : cubic_bezier_triangulated_face;

           face2 : cubic_bezier_triangulated_face;

         
         END_ENTITY;


ENTITY complex_triangulated_face

           SUBTYPE OF (tessellated_face);

           pnindex : LIST[0:?] OF INTEGER;

           triangle_strips : LIST[0:?] OF LIST[3:?] OF INTEGER;

           triangle_fans : LIST[0:?] OF LIST[3:?] OF INTEGER;
WHERE

           WR1: ((SIZEOF(pnindex) = 0) OR (SIZEOF(pnindex) = SELF\tessellated_face.pnmax));

           WR2: NOT((SIZEOF(pnindex) = 0) AND (SELF\tessellated_face.pnmax <> coordinates.npoints));

           WR3: NOT ((SIZEOF(triangle_strips) = 0) AND (SIZEOF(triangle_fans) = 0));

         
         END_ENTITY;


ENTITY cubic_bezier_triangulated_face

           SUBTYPE OF (tessellated_face);

           ctriangles : LIST[1:?] OF LIST[10:10] OF INTEGER;
WHERE

           WR1: SIZEOF( SELF\tessellated_face.normals) = 0;

         
         END_ENTITY;


ENTITY tessellated_solid

           SUBTYPE OF (tessellated_item);

           items : SET[1:?] OF tessellated_structured_item;

           geometric_link : 
         OPTIONAL 
         manifold_solid_brep;

         
         END_ENTITY;


ENTITY tessellated_shell

           SUBTYPE OF (tessellated_item);

           items : SET[1:?] OF tessellated_structured_item;

           topological_link : 
         OPTIONAL 
         connected_face_set;

         
         END_ENTITY;


ENTITY tessellated_wire

           SUBTYPE OF (tessellated_item);

           items : SET[1:?] OF tessellated_edge_or_vertex;

           geometric_model_link : 
         OPTIONAL 
         path_or_composite_curve;

         
         END_ENTITY;


ENTITY tessellated_surface_set

           ABSTRACT SUPERTYPE
         
         OF (ONEOF (triangulated_surface_set,
                                complex_triangulated_surface_set))

           SUBTYPE OF (tessellated_item);

           coordinates : coordinates_list;

           pnmax : INTEGER;

           normals : LIST[0:?] OF LIST[3:3] OF REAL;
WHERE

           WR1: ((SIZEOF(normals) = 0) OR (SIZEOF(normals) = 1) OR (SIZEOF(normals) = pnmax));

         
         END_ENTITY;


ENTITY triangulated_surface_set

           SUBTYPE OF (tessellated_surface_set);

           pnindex : LIST[0:?] OF INTEGER;

           triangles : LIST[1:?] OF LIST[3:3] OF INTEGER;
WHERE

           WR1: ((SIZEOF(pnindex) = 0) OR (SIZEOF(pnindex) = SELF\tessellated_surface_set.pnmax));

           WR2: NOT((SIZEOF(pnindex) = 0) AND (SELF\tessellated_surface_set.pnmax <> coordinates.npoints));

         
         END_ENTITY;


ENTITY complex_triangulated_surface_set

           SUBTYPE OF (tessellated_surface_set);

           pnindex : LIST[0:?] OF INTEGER;

           triangle_strips : LIST[0:?] OF LIST[3:?] OF INTEGER;

           triangle_fans : LIST[0:?] OF LIST[3:?] OF INTEGER;
WHERE

           WR1: ((SIZEOF(pnindex) = 0) OR (SIZEOF(pnindex) = SELF\tessellated_surface_set.pnmax));

           WR2: NOT((SIZEOF(pnindex) = 0) AND (SELF\tessellated_surface_set.pnmax <> coordinates.npoints));

           WR3: NOT ((SIZEOF(triangle_strips) = 0) AND (SIZEOF(triangle_fans) = 0));

         
         END_ENTITY;


ENTITY tessellated_curve_set

           SUBTYPE OF (tessellated_item);

           coordinates : coordinates_list;

           line_strips : LIST[1:?] OF LIST[2:?] OF INTEGER;

         
         END_ENTITY;


ENTITY tessellated_geometric_set

           SUBTYPE OF (tessellated_item);

           children : SET[1:?] OF tessellated_item;

         
         END_ENTITY;


ENTITY tessellated_point_set

           SUBTYPE OF (tessellated_item);

           coordinates : coordinates_list;

           point_list : LIST[1:?] OF INTEGER;

         
         END_ENTITY;


ENTITY tessellated_shape_representation_with_accuracy_parameters

           SUBTYPE OF (tessellated_shape_representation);

           tessellation_accuracy_parameters : SET[1:?] OF tessellation_accuracy_parameter_item;

         
         END_ENTITY;


FUNCTION acyclic_set_replica
 (rep : geometric_set_replica; parent : geometric_set) : BOOLEAN;

IF NOT (('GEOMETRY_SCHEMA.GEOMETRIC_SET_REPLICA') IN TYPEOF(parent))
        THEN  RETURN (TRUE);
   END_IF;
 (* Return TRUE if the parent is not of type geometric_set_replica *)
   IF (parent :=: rep) THEN
      RETURN (FALSE);
  (* Return FALSE if the parent is the same geometric_set_replica,
     otherwise, call function again with the parents own parent_set.  *)
    ELSE RETURN(acyclic_set_replica(rep,
                          parent\geometric_set_replica.parent_set));
    END_IF;


         END_FUNCTION;


FUNCTION acyclic_solid_replica
 (rep : solid_replica; parent : solid_model) : BOOLEAN;

IF NOT (('GEOMETRY_SCHEMA.SOLID_REPLICA') IN TYPEOF(parent)) THEN
      RETURN (TRUE);
   END_IF;
 (* Return TRUE if the parent is not of type solid_replica. *)
   IF (parent :=: rep) THEN
      RETURN (FALSE);
  (* Return FALSE if the parent is the same solid_replica, otherwise,
   call function again with the parents own parent_solid.     *)
    ELSE RETURN(acyclic_solid_replica(rep,
                      parent\solid_replica.parent_solid));
    END_IF;


         END_FUNCTION;


FUNCTION build_transformed_set
 (tr : cartesian_transformation_operator; gset : geometric_set) : SET[0:?] OF geometric_set_select;

LOCAL
   s          : SET [1:?] OF geometric_set_select := gset.elements;
   trset      : SET [0:?] OF geometric_set_select := [];
  END_LOCAL;
  REPEAT j := 1 TO SIZEOF(s);
    IF ('GEOMETRY_SCHEMA.CURVE' IN TYPEOF(s[j])) THEN
     trset := trset + dummy_gri || curve() ||curve_replica(s[j],tr); ELSE
     IF ('GEOMETRY_SCHEMA.POINT' IN TYPEOF(s[j])) THEN
       trset := trset + dummy_gri || point() || point_replica(s[j],tr);
       ELSE
       IF ('GEOMETRY_SCHEMA.SURFACE' IN TYPEOF(s[j])) THEN
         trset := trset + dummy_gri || surface()  || surface_replica(s[j],
           tr || cartesian_transformation_operator_3d (?));
       END_IF;
     END_IF;
    END_IF;
  END_REPEAT;
  RETURN(trset);


         END_FUNCTION;


FUNCTION constraints_geometry_shell_based_surface_model
 (m : shell_based_surface_model) : BOOLEAN;

LOCAL
     result : BOOLEAN := TRUE;
   END_LOCAL;
   
   REPEAT j := 1 TO SIZEOF(m.sbsm_boundary);
     IF (NOT ('TOPOLOGY_SCHEMA.OPEN_SHELL' IN
                     TYPEOF(m.sbsm_boundary[j])) AND
        (NOT ('TOPOLOGY_SCHEMA.CLOSED_SHELL' IN
           TYPEOF(m.sbsm_boundary[j]))))
     THEN
       result := FALSE;
       RETURN(result);
       (* A surface model is composed of OPEN_ and CLOSED_SHELLs. *)
     END_IF;
   END_REPEAT;
   RETURN(result);


         END_FUNCTION;


FUNCTION constraints_geometry_shell_based_wireframe_model
 (m : shell_based_wireframe_model) : BOOLEAN;

LOCAL
     result : BOOLEAN := TRUE;
   END_LOCAL;

   REPEAT j := 1 TO SIZEOF(m.sbwm_boundary);
     IF (NOT ('TOPOLOGY_SCHEMA.WIRE_SHELL' IN
                    TYPEOF(m.sbwm_boundary[j])) AND
        (NOT ('TOPOLOGY_SCHEMA.VERTEX_SHELL' IN
                      TYPEOF(m.sbwm_boundary[j]))))
     THEN
       result := FALSE;
       RETURN(result);
       (* A wireframe model is composed of WIRE_ and VERTEX_SHELLs *)
     END_IF;
   END_REPEAT;
   RETURN(result);


         END_FUNCTION;


FUNCTION msb_shells
 (brep : manifold_solid_brep) : SET[1:?] OF closed_shell;

LOCAL   
      return_set: SET[1:?] OF closed_shell := [brep.outer];   
    END_LOCAL;   

    IF SIZEOF(QUERY(msbtype <* TYPEOF(brep) |   
                 msbtype LIKE '*BREP_WITH_VOIDS'))  >= 1    
          THEN   
       return_set := return_set + brep\brep_with_voids.voids;   
    END_IF;   
   RETURN(return_set);


         END_FUNCTION;



         END_SCHEMA;  -- geometric_model_schema