ISO 10303-46:2021(E)


Integrated generic resource: Visual presentation	ISO 10303-46: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 Presentation organization
4.1 General
4.2 Fundamental concepts and assumptions
4.3 Presentation organization type definitions
4.4 Presentation organization entity definitions
4.5 Presentation organization subtype constraint definition
4.6 Presentation organization function definitions
4.7 Presentation organization rule definitions
5 Presentation definition
5.1 General
5.2 Fundamental concepts and assumptions
5.3 Presentation definition type definitions
5.4 Presentation definition entity definitions
5.5 Presentation definition subtype constraint definition
5.6 Presentation definition function definitions
6 Presentation appearance
6.1 General
6.2 Fundamental concepts and assumptions
6.3 Presentation appearance type definitions
6.4 Presentation appearance entity definitions
6.5 Presentation appearance subtype constraint definitions
6.6 Presentation appearance function definitions
7 Presentation resource
7.1 General
7.2 Fundamental concepts and assumptions
7.3 Presentation resource type definitions
7.4 Presentation resource entity definitions
7.5 Presentation resource subtype constraint definition

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


         (*
ISO/TC 184/SC 4/WG 12 N10472 - ISO 10303-46 Visual presentation - EXPRESS
Supersedes 
         ISO/TC 184/SC 4/WG 12 N9771
*)




            SCHEMA presentation_appearance_schema;


         REFERENCE FROM 
         external_reference_schema   -- ISO 10303-41
  (externally_defined_item,

           
         pre_defined_item);


         REFERENCE FROM 
         geometric_model_schema   -- ISO 10303-42
  (complex_triangulated_face,

           
         coordinates_list,

           
         tessellated_edge,

           
         tessellated_face,

           
         tessellated_item,

           
         tessellated_shell,

           
         tessellated_solid,

           
         tessellated_surface_set,

           
         tessellated_vertex,

           
         triangulated_face);


         REFERENCE FROM 
         geometry_schema   -- ISO 10303-42
  (axis2_placement,

           
         b_spline_curve,

           
         cartesian_point,

           
         composite_curve,

           
         curve,

           
         geometric_representation_item,

           
         point,

           
         polyline,

           
         vector);


         REFERENCE FROM 
         group_schema   -- ISO 10303-41
  (group);


         REFERENCE FROM 
         measure_schema   -- ISO 10303-41
  (descriptive_measure,

           
         length_measure,

           
         measure_with_unit,

           
         plane_angle_measure,

           
         positive_length_measure,

           
         positive_ratio_measure,

           
         ratio_measure);


         REFERENCE FROM 
         presentation_definition_schema   -- ISO 10303-46
  (annotation_curve_occurrence,

           
         annotation_fill_area,

           
         annotation_symbol_occurrence,

           
         annotation_text_with_delineation,

           
         symbol_representation_with_blanking_box);


         REFERENCE FROM 
         presentation_organization_schema   -- ISO 10303-46
  (area_dependent_annotation_representation,

           
         presentation_area,

           
         presentation_layer_assignment,

           
         presentation_layer_usage,

           
         presentation_representation,

           
         presentation_set,

           
         presentation_view,

           
         product_data_representation_view,

           
         view_dependent_annotation_representation);


         REFERENCE FROM 
         presentation_resource_schema   -- ISO 10303-46
  (character_glyph_symbol_outline,

           
         character_glyph_symbol_stroke,

           
         colour);


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


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

           
         mapped_item,

           
         representation,

           
         representation_item,

           
         representation_map,

           
         representation_or_representation_reference,

           
         representation_relationship,

           
         using_representations);


         REFERENCE FROM 
         support_resource_schema   -- ISO 10303-41
  (bag_to_set,

           
         label);


         REFERENCE FROM 
         topology_schema   -- ISO 10303-42
  (topological_representation_item);


TYPE approximation_method =
         
         ENUMERATION
         
         OF
         

            
         (chordal_deviation,
    chordal_length);

         END_TYPE;


TYPE box_characteristic_select =
         
         
         SELECT

            (box_height, 
    box_width, 
    box_slant_angle, 
    box_rotate_angle);

         END_TYPE;


TYPE box_height =
         positive_ratio_measure;

         END_TYPE;


TYPE box_rotate_angle =
         plane_angle_measure;

         END_TYPE;


TYPE box_slant_angle =
         plane_angle_measure;

         END_TYPE;


TYPE box_width =
         positive_ratio_measure;

         END_TYPE;


TYPE character_spacing_select =
         
         
         SELECT

            (length_measure, 
    ratio_measure, 
    measure_with_unit, 
    descriptive_measure, 
    pre_defined_character_spacing);

         END_TYPE;


TYPE character_style_select =
         
         
         SELECT

            (character_glyph_style_stroke, 
    character_glyph_style_outline, 
    text_style_for_defined_font);

         END_TYPE;


TYPE colour_type_enum =
         
         ENUMERATION
         
         OF
         

            
         (RGB8,
    RGBT8);

         END_TYPE;


TYPE curve_font_or_scaled_curve_font_select =
         
         
         SELECT

            (curve_style_font_select, 
    curve_style_font_and_scaling);

         END_TYPE;


TYPE curve_or_annotation_curve_occurrence =
         
         
         SELECT

            (curve, 
    annotation_curve_occurrence);

         END_TYPE;


TYPE curve_or_render =
         
         
         SELECT

            (curve_style, 
    curve_style_rendering);

         END_TYPE;


TYPE curve_style_font_select =
         
         
         SELECT

            (curve_style_font, 
    pre_defined_curve_font, 
    externally_defined_curve_font);

         END_TYPE;


TYPE curve_tolerance_deviation =
         positive_length_measure;

         END_TYPE;


TYPE curve_tolerance_parameter =
         REAL;

         END_TYPE;


TYPE direction_count_select =
         
         
         SELECT

            (u_direction_count, 
    v_direction_count);

         END_TYPE;


TYPE fill_area_style_tile_shape_select =
         
         
         SELECT

            (fill_area_style_tile_curve_with_style, 
    fill_area_style_tile_coloured_region, 
    fill_area_style_tile_symbol_with_style, 
    pre_defined_tile, 
    externally_defined_tile);

         END_TYPE;


TYPE fill_style_select =
         
         
         SELECT

            (fill_area_style_colour, 
    pre_defined_tile_style, 
    externally_defined_tile_style, 
    fill_area_style_tiles, 
    pre_defined_hatch_style, 
    externally_defined_hatch_style, 
    fill_area_style_hatching, 
    texture_style_specification);

         END_TYPE;


TYPE hiding_or_blanking_select =
         
         
         SELECT

            (presentation_area, 
    presentation_view, 
    product_data_representation_view, 
    annotation_fill_area, 
    area_dependent_annotation_representation, 
    view_dependent_annotation_representation, 
    annotation_text_with_delineation, 
    character_glyph_symbol_stroke, 
    character_glyph_symbol_outline, 
    symbol_representation_with_blanking_box);

         END_TYPE;


TYPE invisibility_context =
         
         EXTENSIBLE
         
         GENERIC_ENTITY
         
         
         SELECT

            (presentation_layer_usage, 
    presentation_representation, 
    presentation_set);

         END_TYPE;


TYPE invisible_item =
         
         EXTENSIBLE
         
         GENERIC_ENTITY
         
         
         SELECT

            (styled_item, 
    presentation_layer_assignment, 
    representation);

         END_TYPE;


TYPE marker_select =
         
         
         SELECT

            (marker_type, 
    pre_defined_marker);

         END_TYPE;


TYPE marker_type =
         
         ENUMERATION
         
         OF
         

            
         (dot,
    x,
    plus,
    asterisk,
    ring,
    square,
    triangle);

         END_TYPE;


TYPE non_negative_real =
         REAL;
WHERE

           WR1: 0.0 <= SELF;

         END_TYPE;


TYPE null_style =
         
         ENUMERATION
         
         OF
         

            
         (null);

         END_TYPE;


TYPE presentation_style_select =
         
         
         SELECT

            (pre_defined_presentation_style, 
    point_style, 
    curve_style, 
    surface_style_usage, 
    symbol_style, 
    fill_area_style, 
    text_style, 
    texture_style_tessellation_specification, 
    approximation_tolerance, 
    externally_defined_style, 
    null_style);

         END_TYPE;


TYPE product_or_presentation_space =
         
         ENUMERATION
         
         OF
         

            
         (product_shape_space,
    presentation_area_space);

         END_TYPE;


TYPE rendering_properties_select =
         
         
         SELECT

            (surface_style_reflectance_ambient, 
    surface_style_transparent);

         END_TYPE;


TYPE shading_curve_method =
         
         ENUMERATION
         
         OF
         

            
         (constant_colour,
    linear_colour);

         END_TYPE;


TYPE shading_surface_method =
         
         ENUMERATION
         
         OF
         

            
         (constant_shading,
    colour_shading,
    dot_shading,
    normal_shading);

         END_TYPE;


TYPE size_select =
         
         
         SELECT

            (positive_length_measure, 
    measure_with_unit, 
    descriptive_measure, 
    pre_defined_size);

         END_TYPE;


TYPE squared_or_rounded =
         
         ENUMERATION
         
         OF
         

            
         (squared,
    rounded);

         END_TYPE;


TYPE style_context_select =
         
         
         SELECT

            (group, 
    context_dependent_shape_representation, 
    presentation_layer_assignment, 
    presentation_set, 
    representation, 
    representation_item, 
    representation_relationship);

         END_TYPE;


TYPE styled_item_target =
         
         
         SELECT

            (geometric_representation_item, 
    mapped_item, 
    representation_or_representation_reference, 
    topological_representation_item);

         END_TYPE;


TYPE surface_side =
         
         ENUMERATION
         
         OF
         

            
         (positive,
    negative,
    both);

         END_TYPE;


TYPE surface_side_style_select =
         
         
         SELECT

            (surface_side_style, 
    pre_defined_surface_side_style);

         END_TYPE;


TYPE surface_style_element_select =
         
         
         SELECT

            (surface_style_fill_area, 
    surface_style_boundary, 
    surface_style_silhouette, 
    surface_style_segmentation_curve, 
    surface_style_control_grid, 
    surface_style_parameter_line, 
    surface_style_rendering);

         END_TYPE;


TYPE surface_tolerance_deviation =
         positive_length_measure;

         END_TYPE;


TYPE surface_tolerance_parameter =
         REAL;

         END_TYPE;


TYPE symbol_style_select =
         
         
         SELECT

            (symbol_element_style, 
    symbol_colour);

         END_TYPE;


TYPE tessellated_face_or_tessellated_surface_set =
         
         
         SELECT

            (tessellated_face, 
    tessellated_surface_set);

         END_TYPE;


TYPE tessellated_surface_item =
         
         
         SELECT

            (tessellated_face, 
    tessellated_shell, 
    tessellated_solid, 
    tessellated_surface_set);

         END_TYPE;


TYPE text_justification =
         label;

         END_TYPE;


TYPE texture_file_type =
         
         ENUMERATION
         
         OF
         

            
         (JPEG,
    PNG,
    GIF,
    TIFF,
    BMP,
    DDS,
    TGA,
    other);

         END_TYPE;


TYPE tolerance_deviation_select =
         
         
         SELECT

            (curve_tolerance_deviation, 
    surface_tolerance_deviation);

         END_TYPE;


TYPE tolerance_parameter_select =
         
         
         SELECT

            (curve_tolerance_parameter, 
    surface_tolerance_parameter);

         END_TYPE;


TYPE tolerance_select =
         
         
         SELECT

            (approximation_tolerance_deviation, 
    approximation_tolerance_parameter);

         END_TYPE;


TYPE u_direction_count =
         INTEGER;
WHERE

           WR1: SELF > 1;

         END_TYPE;


TYPE unsigned_8_bit_integer =
         INTEGER;
WHERE

           WR1: { 0 <= SELF <= 255 };

         END_TYPE;


TYPE v_direction_count =
         INTEGER;
WHERE

           WR1: SELF > 1;

         END_TYPE;


ENTITY approximation_tolerance

           SUBTYPE OF (founded_item);

           tolerance : tolerance_select;

         
         END_ENTITY;


ENTITY approximation_tolerance_deviation

           SUBTYPE OF (founded_item);

           tessellation_type : approximation_method;

           tolerances : SET[1:2] OF tolerance_deviation_select;

           definition_space : product_or_presentation_space;
WHERE

           WR1: (HIINDEX(tolerances) = 1)
            XOR
            (TYPEOF(tolerances[1]) <> TYPEOF(tolerances[2]));

         
         END_ENTITY;


ENTITY approximation_tolerance_parameter

           SUBTYPE OF (founded_item);

           tolerances : SET[1:2] OF tolerance_parameter_select;
WHERE

           WR1: (HIINDEX (tolerances) = 1 )
            XOR
            (TYPEOF (tolerances[1]) <> TYPEOF (tolerances[2]));

         
         END_ENTITY;


ENTITY character_glyph_style_outline

           SUBTYPE OF (founded_item);

           outline_style : curve_style;

         
         END_ENTITY;


ENTITY character_glyph_style_outline_with_characteristics

           SUBTYPE OF (character_glyph_style_outline);

           characteristics : fill_area_style;

         
         END_ENTITY;


ENTITY character_glyph_style_stroke

           SUBTYPE OF (founded_item);

           stroke_style : curve_style;

         
         END_ENTITY;


ENTITY context_dependent_invisibility

           SUBTYPE OF (invisibility);

           presentation_context : invisibility_context;

         
         END_ENTITY;


ENTITY context_dependent_over_riding_styled_item

           SUBTYPE OF (over_riding_styled_item);

           style_context : LIST[1:?] OF style_context_select;
WHERE

           WR1: (SIZEOF(QUERY(sc <* style_context | 'REPRESENTATION_SCHEMA.REPRESENTATION_ITEM' IN TYPEOF(sc)))= 1) OR
            (SIZEOF(QUERY(sc <* style_context |
            ('REPRESENTATION_SCHEMA.MAPPED_ITEM' IN TYPEOF(sc))
            OR ('PRESENTATION_APPEARANCE_SCHEMA.CONTEXT_DEPENDENT_SHAPE_REPRESENTATION' IN TYPEOF(sc))
            OR ('REPRESENTATION_SCHEMA.REPRESENTATION_RELATIONSHIP' IN TYPEOF(sc)) ))
            = SIZEOF(style_context));

         
         END_ENTITY;


ENTITY curve_style

           SUBTYPE OF (founded_item);

           name : label;

           curve_font : 
         OPTIONAL 
         curve_font_or_scaled_curve_font_select;

           curve_width : 
         OPTIONAL 
         size_select;

           curve_colour : 
         OPTIONAL 
         colour;
WHERE

           WR1: EXISTS(curve_font) OR EXISTS(curve_width) OR EXISTS(curve_colour);

         
         END_ENTITY;


ENTITY curve_style_curve_pattern

           SUBTYPE OF (geometric_representation_item);

           pattern : annotation_curve_occurrence;

           pattern_length : positive_length_measure;

         
         END_ENTITY;


ENTITY curve_style_curve_pattern_set

           SUBTYPE OF (curve_style_font, geometric_representation_item);

           pattern_set : SET[1:?] OF curve_style_curve_pattern;

         
         END_ENTITY;


ENTITY curve_style_font

           SUBTYPE OF (founded_item);

           name : label;

           pattern_list : LIST[1:?] OF curve_style_font_pattern;

         
         END_ENTITY;


ENTITY curve_style_font_and_scaling

           SUBTYPE OF (founded_item);

           name : label;

           curve_font : curve_style_font_select;

           curve_font_scaling : REAL;

         
         END_ENTITY;


ENTITY curve_style_font_pattern

           SUBTYPE OF (founded_item);

           visible_segment_length : positive_length_measure;

           invisible_segment_length : positive_length_measure;

         
         END_ENTITY;


ENTITY curve_style_rendering;

           rendering_method : shading_curve_method;

           rendering_properties : surface_rendering_properties;

         
         END_ENTITY;


ENTITY curve_style_wide

           SUBTYPE OF (curve_style_font);

           interior_style : fill_area_style;

         
         END_ENTITY;


ENTITY curve_style_with_ends_and_corners

           SUBTYPE OF (curve_style);

           curve_ends : squared_or_rounded;

           curve_corners : squared_or_rounded;
WHERE

           WR1: EXISTS(curve_width);

         
         END_ENTITY;


ENTITY curve_style_with_extension

           SUBTYPE OF (curve_style);

           curve_extensions : length_measure;
WHERE

           WR1: EXISTS(curve_width);

         
         END_ENTITY;


ENTITY draughting_pre_defined_curve_font

           SUBTYPE OF (pre_defined_curve_font);
WHERE

           WR1: SELF\pre_defined_item.name IN
            ['continuous',
            'chain',
            'chain double dash',
            'dashed',
            'dotted'];

         
         END_ENTITY;


ENTITY externally_defined_curve_font

           SUBTYPE OF (externally_defined_item);

         
         END_ENTITY;


ENTITY externally_defined_hatch_style

           SUBTYPE OF (externally_defined_item, geometric_representation_item);

         
         END_ENTITY;


ENTITY externally_defined_style

           SUBTYPE OF (externally_defined_item, founded_item);

         
         END_ENTITY;


ENTITY externally_defined_tile

           SUBTYPE OF (externally_defined_item);

         
         END_ENTITY;


ENTITY externally_defined_tile_style

           SUBTYPE OF (externally_defined_item, geometric_representation_item);

         
         END_ENTITY;


ENTITY fill_area_style

           SUBTYPE OF (founded_item);

           name : label;

           fill_styles : SET[1:?] OF fill_style_select;
WHERE

           WR1: SIZEOF(QUERY(fill_style <* fill_styles |
            'PRESENTATION_APPEARANCE_SCHEMA.'+
            'FILL_AREA_STYLE_COLOUR' IN
            TYPEOF(fill_style)
            )) <= 1;

         
         END_ENTITY;


ENTITY fill_area_style_colour;

           name : label;

           fill_colour : colour;

         
         END_ENTITY;


ENTITY fill_area_style_hatching

           SUBTYPE OF (geometric_representation_item);

           hatch_line_appearance : curve_style;

           start_of_next_hatch_line : one_direction_repeat_factor;

           point_of_reference_hatch_line : cartesian_point;

           pattern_start : cartesian_point;

           hatch_line_angle : plane_angle_measure;

         
         END_ENTITY;


ENTITY fill_area_style_tile_coloured_region

           SUBTYPE OF (geometric_representation_item);

           closed_curve : curve_or_annotation_curve_occurrence;

           region_colour : colour;
WHERE

           WR1: (NOT('GEOMETRY_SCHEMA.CURVE' IN TYPEOF (closed_curve))) OR 
            ('GEOMETRY_SCHEMA.CIRCLE' IN TYPEOF (closed_curve)) OR 
            ('GEOMETRY_SCHEMA.ELLIPSE' IN TYPEOF (closed_curve)) OR 
            ( ('GEOMETRY_SCHEMA.B_SPLINE_CURVE' IN TYPEOF (closed_curve)) 
            AND (closed_curve\b_spline_curve.closed_curve = TRUE) ) OR 
            ( ('GEOMETRY_SCHEMA.COMPOSITE_CURVE' IN TYPEOF (closed_curve)) 
            AND (closed_curve\composite_curve.closed_curve = TRUE) ) OR 
            ( ('GEOMETRY_SCHEMA.POLYLINE' IN TYPEOF (closed_curve)) 
            AND (closed_curve\polyline.points[LOINDEX(closed_curve\polyline.points)] = 
            closed_curve\polyline.points[HIINDEX(closed_curve\polyline.points)]) );

         
         END_ENTITY;


ENTITY fill_area_style_tile_curve_with_style

           SUBTYPE OF (geometric_representation_item);

           styled_curve : annotation_curve_occurrence;

         
         END_ENTITY;


ENTITY fill_area_style_tile_symbol_with_style

           SUBTYPE OF (geometric_representation_item);

           symbol : annotation_symbol_occurrence;

         
         END_ENTITY;


ENTITY fill_area_style_tiles

           SUBTYPE OF (geometric_representation_item);

           tiling_pattern : two_direction_repeat_factor;

           tiles : SET[1:?] OF fill_area_style_tile_shape_select;

           tiling_scale : positive_ratio_measure;

         
         END_ENTITY;


ENTITY invisibility;

           invisible_items : SET[1:?] OF invisible_item;

         
         END_ENTITY;


ENTITY occlusion_precedence;

           higher_precedence : hiding_or_blanking_select;

           lower_precedence : hiding_or_blanking_select;

           occlusion_context : representation;
WHERE

           WR1: acyclic_occlusion_precedence (SELF, [lower_precedence]);

         
         END_ENTITY;


ENTITY one_direction_repeat_factor

           SUBTYPE OF (geometric_representation_item);

           repeat_factor : vector;

         
         END_ENTITY;


ENTITY over_riding_styled_item

           SUBTYPE OF (styled_item);

           over_ridden_style : styled_item;

         
         END_ENTITY;


ENTITY point_style

           SUBTYPE OF (founded_item);

           name : label;

           marker : 
         OPTIONAL 
         marker_select;

           marker_size : 
         OPTIONAL 
         size_select;

           marker_colour : 
         OPTIONAL 
         colour;
WHERE

           WR1: EXISTS(marker) OR EXISTS(marker_size) OR EXISTS(marker_colour);

         
         END_ENTITY;


ENTITY pre_defined_character_spacing

           SUBTYPE OF (pre_defined_item);

         
         END_ENTITY;


ENTITY pre_defined_curve_font

           SUBTYPE OF (pre_defined_item);

         
         END_ENTITY;


ENTITY pre_defined_hatch_style

           SUBTYPE OF (pre_defined_item, geometric_representation_item);

         
         END_ENTITY;


ENTITY pre_defined_marker

           SUBTYPE OF (pre_defined_item);

         
         END_ENTITY;


ENTITY pre_defined_presentation_style

           SUBTYPE OF (founded_item, pre_defined_item);

         
         END_ENTITY;


ENTITY pre_defined_size

           SUBTYPE OF (pre_defined_item);

         
         END_ENTITY;


ENTITY pre_defined_surface_side_style

           SUBTYPE OF (pre_defined_item);

         
         END_ENTITY;


ENTITY pre_defined_tile

           SUBTYPE OF (pre_defined_item);

         
         END_ENTITY;


ENTITY pre_defined_tile_style

           SUBTYPE OF (pre_defined_item, geometric_representation_item);

         
         END_ENTITY;


ENTITY presentation_style_assignment

           SUBTYPE OF (founded_item);

           styles : SET[1:?] OF presentation_style_select;
WHERE

           WR1: SIZEOF (QUERY (style1 <* styles |
            NOT (SIZEOF (QUERY (style2 <* (styles - style1) |
            NOT ((TYPEOF (style1) <> TYPEOF (style2)) OR
            (SIZEOF (['PRESENTATION_APPEARANCE_SCHEMA.' + 
            'SURFACE_STYLE_USAGE',
            'PRESENTATION_APPEARANCE_SCHEMA.'+
            'EXTERNALLY_DEFINED_STYLE'] *
            TYPEOF (style1)) = 1)
            ))) = 0
            ))) = 0;

           WR2: SIZEOF (QUERY (style1 <* styles |
            'PRESENTATION_APPEARANCE_SCHEMA.SURFACE_STYLE_USAGE' IN
            TYPEOF(style1)
            )) <= 2;

           WR3: SIZEOF (QUERY (style1 <* styles |
            ('PRESENTATION_APPEARANCE_SCHEMA.SURFACE_STYLE_USAGE' IN TYPEOF (style1)) AND 
            (SIZEOF (QUERY (style2 <* (styles - style1) |
            ('PRESENTATION_APPEARANCE_SCHEMA.SURFACE_STYLE_USAGE' IN TYPEOF (style2)) AND 
            ((style1\surface_style_usage.side = both) OR 
            (style2\surface_style_usage.side = both) OR 
            (style1\surface_style_usage.side = style2\surface_style_usage.side)) )) > 0))) = 0;

         
         END_ENTITY;


ENTITY presentation_style_by_context

           SUBTYPE OF (presentation_style_assignment);

           style_context : style_context_select;

         
         END_ENTITY;


ENTITY single_texture_style_tessellation_specification

           SUBTYPE OF (texture_style_tessellation_specification);

           texture_image : label;

           texture_coordinates : LIST[1:?] OF LIST[2:2] OF non_negative_real;

           texture_format : texture_file_type;

           repeating_pattern : BOOLEAN;

         
         END_ENTITY;


ENTITY styled_item

           SUBTYPE OF (representation_item);

           styles : SET[0:?] OF presentation_style_assignment;

           item : styled_item_target;
WHERE

           WR1: (SIZEOF(styles) = 0) AND ( 'PRESENTATION_APPEARANCE_SCHEMA.STYLED_TESSELLATED_ITEM_WITH_COLOURS' IN TYPEOF(self))
            OR
            (SIZEOF(styles) = 1)
            OR
            (SIZEOF(styles) > 1) AND (SIZEOF(QUERY(pres_style <* styles | NOT ('PRESENTATION_APPEARANCE_SCHEMA.' + 'PRESENTATION_STYLE_BY_CONTEXT'
            IN TYPEOF(pres_style)))) = 0);

           WR2: NOT ('PRESENTATION_APPEARANCE_SCHEMA.STYLED_ITEM' IN TYPEOF(item));

           WR3: ('REPRESENTATION_SCHEMA.MAPPED_ITEM' IN TYPEOF(item)) OR
            ('GEOMETRY_SCHEMA.GEOMETRIC_REPRESENTATION_ITEM' IN TYPEOF(item)) OR
            ('PRESENTATION_APPEARANCE_SCHEMA.CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM' IN TYPEOF(SELF));

         
         END_ENTITY;


ENTITY styled_tessellated_face_or_surface_with_single_texture

           SUBTYPE OF (styled_item);

           SELF\styled_item.styles : SET[1:1] OF presentation_style_assignment;

           SELF\styled_item.item : tessellated_face_or_tessellated_surface_set;
DERIVE

           texture_style_specification : texture_style_tessellation_specification := styles[LOINDEX(styles)]\presentation_style_assignment.styles[LOINDEX(styles)];
WHERE

           WR1: ('PRESENTATION_APPEARANCE_SCHEMA.SINGLE_TEXTURE_STYLE_TESSELLATION_SPECIFICATION' IN TYPEOF(styles[LOINDEX(styles)]\presentation_style_assignment.styles[LOINDEX(styles)]))
            AND (SIZEOF(styles[LOINDEX(styles)]\presentation_style_assignment.styles) = 1);

           WR2: NOT ('GEOMETRIC_MODEL_SCHEMA.TRIANGULATED_FACE' IN TYPEOF(item))
            OR
            ((
            ((SIZEOF(item\triangulated_face.pnindex) > 0) AND (SIZEOF(texture_style_specification\single_texture_style_tessellation_specification.texture_coordinates)
            = SIZEOF(item\triangulated_face.pnindex))))
            OR
            ((SIZEOF(item\triangulated_face.pnindex) = 0) AND (SIZEOF(texture_style_specification\single_texture_style_tessellation_specification.texture_coordinates)
            = item\tessellated_face.coordinates\coordinates_list.npoints)));

           WR3: NOT ('GEOMETRIC_MODEL_SCHEMA.COMPLEX_TRIANGULATED_FACE' IN TYPEOF(item))
            OR
            ((SIZEOF(item\complex_triangulated_face.pnindex) > 0) AND (SIZEOF(texture_style_specification\single_texture_style_tessellation_specification.texture_coordinates)
            = SIZEOF(item\complex_triangulated_face.pnindex)))
            OR
            ((SIZEOF(item\complex_triangulated_face.pnindex) = 0) AND (SIZEOF(texture_style_specification\single_texture_style_tessellation_specification.texture_coordinates)
            = item\tessellated_face.coordinates\coordinates_list.npoints));

           WR4: NOT ('GEOMETRIC_MODEL_SCHEMA.TESSELLATED_SURFACE_SET' IN TYPEOF(item))
            OR
            (SIZEOF(texture_style_specification\single_texture_style_tessellation_specification.texture_coordinates) = item\tessellated_surface_set.coordinates\coordinates_list.npoints);

         
         END_ENTITY;


ENTITY styled_tessellated_item_with_colours

           SUBTYPE OF (styled_item);

           SELF\styled_item.item : tessellated_surface_item;

           colour_type : colour_type_enum;

           colour_values : LIST[1:?] OF LIST[3:4] OF unsigned_8_bit_integer;
DERIVE

           coloured_coordinate_values : coordinates_list := get_coordinate_values(item );
WHERE

           WR1: SIZEOF(SELF\styled_item.styles)= 0;

           WR2: ((colour_type = RGB8) AND (SIZEOF(QUERY(clist <* colour_values | NOT (SIZEOF(clist) = 3)))= 0)) OR
            ((colour_type = RGBT8) AND (SIZEOF(QUERY(clist <* colour_values | NOT (SIZEOF(clist) = 4)))= 0));

           WR3: SIZEOF(colour_values) = coloured_coordinate_values\coordinates_list.npoints;

         
         END_ENTITY;


ENTITY surface_rendering_properties;

           rendered_colour : colour;

         
         END_ENTITY;


ENTITY surface_side_style

           SUBTYPE OF (founded_item);

           name : label;

           styles : SET[1:7] OF surface_style_element_select;
WHERE

           WR1: SIZEOF(QUERY( style1 <* styles |
            SIZEOF(QUERY( style2 <* styles - style1 |
            TYPEOF(style1) = TYPEOF(style2)
            )) > 0
            )) = 0;

         
         END_ENTITY;


ENTITY surface_style_boundary

           SUBTYPE OF (founded_item);

           style_of_boundary : curve_or_render;

         
         END_ENTITY;


ENTITY surface_style_control_grid

           SUBTYPE OF (founded_item);

           style_of_control_grid : curve_or_render;

         
         END_ENTITY;


ENTITY surface_style_fill_area

           SUBTYPE OF (founded_item);

           fill_area : fill_area_style;

         
         END_ENTITY;


ENTITY surface_style_parameter_line

           SUBTYPE OF (founded_item);

           style_of_parameter_lines : curve_or_render;

           direction_counts : SET[1:2] OF direction_count_select;
WHERE

           WR1: (HIINDEX(direction_counts) = 1)
            XOR
            (TYPEOF(direction_counts[1]) <>
            TYPEOF(direction_counts[2]));

         
         END_ENTITY;


ENTITY surface_style_reflectance_ambient;

           ambient_reflectance : REAL;

         
         END_ENTITY;


ENTITY surface_style_reflectance_ambient_diffuse

           SUBTYPE OF (surface_style_reflectance_ambient);

           diffuse_reflectance : REAL;

         
         END_ENTITY;


ENTITY surface_style_reflectance_ambient_diffuse_specular

           SUBTYPE OF (surface_style_reflectance_ambient_diffuse);

           specular_reflectance : REAL;

           specular_exponent : REAL;

           specular_colour : colour;

         
         END_ENTITY;


ENTITY surface_style_rendering;

           rendering_method : shading_surface_method;

           surface_colour : colour;

         
         END_ENTITY;


ENTITY surface_style_rendering_with_properties

           SUBTYPE OF (surface_style_rendering);

           properties : SET[1:2] OF rendering_properties_select;
WHERE

           WR1: (HIINDEX(properties) = 1)
            XOR
            (TYPEOF(properties[1]) <> TYPEOF(properties[2]));

         
         END_ENTITY;


ENTITY surface_style_segmentation_curve

           SUBTYPE OF (founded_item);

           style_of_segmentation_curve : curve_or_render;

         
         END_ENTITY;


ENTITY surface_style_silhouette

           SUBTYPE OF (founded_item);

           style_of_silhouette : curve_or_render;

         
         END_ENTITY;


ENTITY surface_style_transparent;

           transparency : REAL;
WHERE

           WR1: {0.0 <= transparency <= 1.0};

         
         END_ENTITY;


ENTITY surface_style_usage

           SUBTYPE OF (founded_item);

           side : surface_side;

           style : surface_side_style_select;

         
         END_ENTITY;


ENTITY symbol_colour;

           colour_of_symbol : colour;

         
         END_ENTITY;


ENTITY symbol_element_style

           SUBTYPE OF (founded_item);

           style_of_symbol : presentation_style_assignment;
WHERE

           WR1: SIZEOF (QUERY ( style <* style_of_symbol\presentation_style_assignment.styles |
            'PRESENTATION_APPEARANCE_SCHEMA.SYMBOL_STYLE' IN
            TYPEOF (style))) = 0;

           WR2: NOT ('PRESENTATION_APPEARANCE_SCHEMA.' +
            'PRESENTATION_STYLE_BY_CONTEXT' IN
            TYPEOF (style_of_symbol)
            );

         
         END_ENTITY;


ENTITY symbol_style

           SUBTYPE OF (founded_item);

           name : label;

           style_of_symbol : symbol_style_select;

         
         END_ENTITY;


ENTITY text_style

           SUBTYPE OF (founded_item);

           name : label;

           character_appearance : character_style_select;

         
         END_ENTITY;


ENTITY text_style_for_defined_font;

           text_colour : colour;

         
         END_ENTITY;


ENTITY text_style_with_box_characteristics

           SUBTYPE OF (text_style);

           characteristics : SET[1:4] OF box_characteristic_select;
WHERE

           WR1: SIZEOF( QUERY( c1 <* characteristics |
            SIZEOF( QUERY( c2 <* characteristics - c1 |
            TYPEOF (c1) = TYPEOF (c2)
            )) > 0
            )) = 0;

         
         END_ENTITY;


ENTITY text_style_with_justification

           SUBTYPE OF (text_style);

           justification : text_justification;

         
         END_ENTITY;


ENTITY text_style_with_mirror

           SUBTYPE OF (text_style);

           mirror_placement : axis2_placement;

         
         END_ENTITY;


ENTITY text_style_with_spacing

           SUBTYPE OF (text_style);

           character_spacing : character_spacing_select;

         
         END_ENTITY;


ENTITY texture_style_specification

           ABSTRACT SUPERTYPE
         

           SUBTYPE OF (founded_item);

         
         END_ENTITY;


ENTITY texture_style_tessellation_specification

           ABSTRACT SUPERTYPE
         

           SUBTYPE OF (texture_style_specification);

         
         END_ENTITY;


ENTITY two_direction_repeat_factor

           SUBTYPE OF (one_direction_repeat_factor);

           second_repeat_factor : vector;

         
         END_ENTITY;


SUBTYPE_CONSTRAINT founded_item_subtypes FOR founded_item;

           ONEOF (approximation_tolerance,
         approximation_tolerance_deviation,
         approximation_tolerance_parameter,
         character_glyph_style_outline,
         character_glyph_style_stroke,
         curve_style,
         curve_style_font,
         curve_style_font_and_scaling,
         curve_style_font_pattern,
         externally_defined_style,
         fill_area_style,
         point_style,
         pre_defined_presentation_style,
         presentation_style_assignment,
         surface_side_style,
         surface_style_boundary,
         surface_style_control_grid,
         surface_style_fill_area,
         surface_style_parameter_line,
         surface_style_segmentation_curve,
         surface_style_silhouette,
         surface_style_usage,
         symbol_element_style,
         symbol_style,
         text_style);
      
         END_SUBTYPE_CONSTRAINT;


SUBTYPE_CONSTRAINT pas_geometric_representation_item_subtypes FOR geometric_representation_item;

           ONEOF (curve,
         curve_style_curve_pattern,
         curve_style_curve_pattern_set,
         externally_defined_hatch_style,
         externally_defined_tile_style,
         fill_area_style_hatching,
         fill_area_style_tile_coloured_region,
         fill_area_style_tile_curve_with_style,
         fill_area_style_tile_symbol_with_style,
         fill_area_style_tiles,
         one_direction_repeat_factor,
         point,
         pre_defined_hatch_style,
         pre_defined_tile_style,
         vector);
      
         END_SUBTYPE_CONSTRAINT;


FUNCTION acyclic_occlusion_precedence
 (relation : occlusion_precedence; set_of_lower : SET[0:?] OF hiding_or_blanking_select) : BOOLEAN;

LOCAL
      x : SET OF occlusion_precedence;
      local_set_of_lower : SET OF hiding_or_blanking_select;
    END_LOCAL;
    REPEAT i:=1 TO HIINDEX(set_of_lower);
      IF relation.higher_precedence :=: set_of_lower[i] THEN
        RETURN(FALSE);
      END_IF;
    END_REPEAT;
    x := bag_to_set (USEDIN ( relation.higher_precedence,
                   'PRESENTATION_APPEARANCE_SCHEMA.'+
           'OCCLUSION_PRECEDENCE.LOWER_PRECEDENCE'));
    local_set_of_lower := set_of_lower + relation.higher_precedence;
    IF SIZEOF (x) > 0 THEN
      REPEAT i:=1 TO HIINDEX (x);
        IF NOT acyclic_occlusion_precedence(x[i] ,
                                     local_set_of_lower) THEN
            RETURN (FALSE);
        END_IF;
      END_REPEAT;
    END_IF;
    RETURN (TRUE);


         END_FUNCTION;


FUNCTION get_coordinate_values
 (source : tessellated_surface_item) : coordinates_list;

LOCAL
      coordinate_values : coordinates_list;
      max : INTEGER;
 END_LOCAL;
       (* If source is of type tessellated_face its single coordinates_list is returned *)  
    CASE TRUE OF
    'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_FACE' IN TYPEOF(source): --first case 
    BEGIN
      coordinate_values := source\tessellated_face.coordinates;
      RETURN(coordinate_values);
    END;
       (* If source is of type tessellated_surface_set its single coordinates_list is returned *)  
   'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_SURFACE_SET' IN TYPEOF(source): --second case
    BEGIN
      coordinate_values := source\tessellated_surface_set.coordinates;
      RETURN(coordinate_values);
    END;    
       (* For complex cases of tessellated_solid or tessellated_shell multiple coordinates_lists
        may occur. A valid return is only possible if a single coordinates_list is used for all components of the shell or solid *)
       (*  A tessellated_solid, or tessellated_shell  has a SET of teessellated_structured_items which must be inspected, the local variable coordinate_values is 
        set to the coordinates_list referenced by items[1] and is later compared to other referenced coordinates_lists *)
   'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_SOLID' IN TYPEOF(source): -- third case
    BEGIN
      IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_FACE' IN TYPEOF(source\tessellated_solid.items[1]) THEN
        coordinate_values := source\tessellated_solid.items[1]\tessellated_face.coordinates;
      END_IF;
     IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_EDGE' IN TYPEOF(source\tessellated_solid.items[1]) THEN
       coordinate_values := source\tessellated_solid.items[1]\tessellated_edge.coordinates;
     END_IF;
     IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_VERTEX' IN TYPEOF(source\tessellated_solid.items[1]) THEN
       coordinate_values := source\tessellated_solid.items[1]\tessellated_vertex.coordinates;
     END_IF;
     max := SIZEOF(source\tessellated_solid.items);
      IF   max = 1 THEN 
       RETURN(coordinate_values);
     (* simple case with only 1 item in the list *)
      ELSE REPEAT i := 2 TO max;
       (* check that each item on the list references the same coordintes_list as items[1], if NOT rerurn ? *) 
        IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_FACE' IN TYPEOF(source\tessellated_solid.items[i]) THEN
          IF NOT(coordinate_values :=: source\tessellated_solid.items[i]\tessellated_face.coordinates) THEN 
           RETURN (?);
          END_IF;  
        END_IF;
        IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_EDGE' IN TYPEOF(source\tessellated_solid.items[i]) THEN
          IF NOT(coordinate_values :=: source\tessellated_solid.items[i]\tessellated_edge.coordinates) THEN
           RETURN(?);
          END_IF;
        END_IF;  
        IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_VERTEX' IN TYPEOF(source\tessellated_solid.items[i]) THEN
         IF NOT(coordinate_values :=: source\tessellated_solid.items[i]\tessellated_vertex.coordinates) THEN
           RETURN(?);
         END_IF;  
       END_IF; 
     END_REPEAT;
     RETURN(coordinate_values);
      (* all items referenced by the tessellated_solid share the same coordinates list which is now returned. *) 
    END_IF;
  END;   
      (* tessellated_shell has a SET of tessellated_structured_items which must be inspected *)
   'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_SHELL' IN TYPEOF(source): --fourth case
    BEGIN
        IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_FACE' IN TYPEOF(source\tessellated_shell.items[1]) THEN
         coordinate_values := source\tessellated_shell.items[1]\tessellated_face.coordinates;
        END_IF;
       IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_EDGE' IN TYPEOF(source\tessellated_shell.items[1]) THEN
         coordinate_values := source\tessellated_shell.items[1]\tessellated_edge.coordinates;
       END_IF;
       IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_VERTEX' IN TYPEOF(source\tessellated_shell.items[1]) THEN
        coordinate_values := source\tessellated_shell.items[1]\tessellated_vertex.coordinates;
       END_IF;
       max := SIZEOF(source\tessellated_shell.items);
       IF  max = 1 THEN RETURN(coordinate_values);
       (* simple case with only 1 item in the list *)
       ELSE REPEAT i := 2 TO max;
        (* check that each item on the list references the same coordinates_list as item[1], if NOT rerurn ? *) 
        IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_FACE' IN TYPEOF(source\tessellated_shell.items[i]) THEN
         IF NOT(coordinate_values :=: source\tessellated_shell.items[i]\tessellated_face.coordinates) THEN 
           RETURN (?);
         END_IF;  
        END_IF;
        IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_EDGE' IN TYPEOF(source\tessellated_shell.items[i]) THEN
          IF NOT (coordinate_values :=: source\tessellated_shell.items[i]\tessellated_edge.coordinates) THEN
            RETURN(?);
          END_IF;
        END_IF;  
        IF 'GEOMETRIC_MODEL_SCHEMA.TESSELLATED_VERTEX' IN TYPEOF(source\tessellated_shell.items[i]) THEN
         IF NOT (coordinate_values :=: source\tessellated_shell.items[i]\tessellated_vertex.coordinates) THEN
           RETURN(?);
         END_IF;  
        END_IF; 
      END_REPEAT;
      RETURN(coordinate_values);
       (* all items referenced by the tessellated_shell share the same coordinates_list which is now returned. *) 
     END_IF;
   END;
   END_CASE;


         END_FUNCTION;



         END_SCHEMA;  -- presentation_appearance_schema