Connect Face Set

Overview

Identifies the information requirements for provision of a connected face set.

Connected face sets are used in the provision of:

Face based surface models
Shell based surface models
Facetted boundary representations (with and without voids)

The aim of a connected face set is to define a set of individual faces as being connected for the purpose of creating a surface model or solid model representation. Connection between faces is achieved by sharing edges and vertices (the intersection between faces). Other than this, intersections in a particular set of connected faces are not allowed.
A face may have a surface described. In this case, the surface is described as being a plane.
An individual face is defined by a bounding loop (the face boundary). This may be specifically described as an outer loop, and there must be one outer loop for a face. If the loop is not defined as an outer loop, it is considered to be an inner loop that describes a hole in the face. Loops have an orientation set as TRUE or FALSE that describes their direction.
A loop may be defined in various ways:

A polyloop has straight edges. It is a polygon whose shape is specified by the set of Cartesian points marking its vertices. Note that outer loop (face boundary) must be a polyloops even if inner loops are defined otherwise.
An edge loop is specified by the edges that form the loop. An edge loop cannot form the boundary of a face and so can only represent a hole on a face within a face based surface model. The requirement is that the endpoint of the final edge in the loop must be coincident with the startpoint of the first edge in the loop. Since the loop should be closed, the endpoint of each edge should in fact be coincident with the startpoint of the succeeding edge. This implies ordering of the edges within the loop in a sequence from first edge to last or closing edge. Each edge in the loop is oriented and is defined by a starting vertex point and ending vertex point.
Note that, at this stage, the IFC model expects face bounds to be polyloops. Edge loops should not be used.

Results

A connected face set that can be used in a surface model or solid model representation is defined.

|| Description || Entity/Pset/Functional Part || MAN || REC || OPT ||

Create the surface model without surfaces
Determine the points in the polygon.	IfcCartesianPoint.Coordinates::IfcLengthMeasure
Set the dimensionality of the point to 3 (3 dimensional point) This is a derived attribute and should be set directly	IfcCartesianPoint.Dim::IfcDimensionCount = 3
Determine the sequence in which the points of the polygon occur and collect them into a list that defines the polygon loop. There must be a minimum of 3 points in the list.	IfcPolyloop.Polygon::IfcCartesianPoint
Define the loop as a face boundary. If it is to be an outer face, then define the boundary as an outer face boundary.	IfcFaceBound.Bound::IfcPolyLoop IfcFaceOuterBound.Bound::IfcPolyLoop
Set the orientation attribute of the face boundary. Generally, it is anticipated that the loop will be defined immediately as a face boundary and therefore the orientation should be set to TRUE for a polyloop. However, the loop may be defined independently and then assigned to being a face bound. In this case, the orientation when initially defined and when used may differ in which case the orientation should be set to FALSE. If they do not differ, then the value should be set to TRUE.	IfcFaceBound.Orientation::BOOLEAN
Specify the face for which the boundary is being set. Note that a face may contain a set of boundaries defining outer and inner faces. Ensure that at least one of the boundaries is an occurrence of an outer boundary.	IfcFace.Bounds::IfcFaceBound
Determine the set of faces that are to be connected and assign them to a connected face set.	IfcConnectedFace.CfsFaces::IfcFace
Add surfaces to faces
Identify the face as being a surface through the face surface subtype A curve bounded plane is a subtype of IfcBoundedSurface which is itself a subtype of IfcSurface	IfcFaceSurface.Surface::IfcCurveBoundedPlane
Set the flag to indicate whether the sense of the surface normal agrees with (TRUE), or opposes (FALSE), the sense of the topological normal to the face.	IfcFaceSurface.SameSense::BOOLEAN
Basis surface
Determine the basis surface (plane) for the surface.	IfcCurveBoundedPlane.BasisSurface::IfcPlane
Determine the position of the plane surface	IfcPlane.Position::IfcAxis2Placement3D
Set the direction of the Z axis of the surface	IfcAxis2Placement3D.Axis::IfcDirection
Set the direction of the local X axis of the surface	IfcAxis2Placement3D.RefDirection::IfcDirection
The normalized directions of the placement are derived	IfcAxis2Placement3D.P::IfcDirection
Set the components of the direction vectors	IfcDirection.DirectionRatios::REAL
Set the value of the dimensionality of the direction as 3 This is a derived attribute and should be set directly IfcDirection.	Dim::IfcDimensionCount = 3
Outer boundary of the surface
Determine the outer boundary of the surface A polyline is the subtype of curve used for the boundary of a face	IfcCurveBoundedPlane.OuterBoundary::fp_represent_polyline
Inner boundaries of the surface
Determine the inner boundaries of the surface This would be used only if there are inner boundaries describing voids (holes) in the surface. Note that there may be more than one void in a surface and therefore this relationship allows for the specification of a set of inner boundaries. The required type of curve and dimensionality specification of each inner boundary curve is the same as for the outer boundary curve as described above.	IfcCurveBoundedPlane.InnerBoundaries::fp_represent_polyline

IFC Entities Required

IfcAxis2Placement3D
IfcBoundedCurve
IfcBoundedSurface
IfcCartesianPoint
IfcConnectedFaceSet
IfcCurve
IfcCurveBoundedPlane
IfcDirection
IfcEdge
IfcEdgeLoop
IfcElementarySurface
IfcFace
IfcFaceBound
IfcFaceOuterBound
IfcGeometricRepresentationItem
IfcLoop
IfcOrientedEdge
IfcPlacement
IfcPlane
IfcPoint
IfcPolyLoop
IfcRepresentationItem
IfcSurface
IfcTopologicalRepresentationItem
IfcVertex
IfcVertexLoop
IfcVertexPoint

IFC Datatypes Required

IfcDimensionCount
IfcLengthMeasure

IFC Functions Required

IfcCrossProduct
*IfcLoopToTail

IDM Functional Parts Required

fp_represent_polyline

EXPRESS-G

EXPRESS Schema

SCHEMA FP_CONNECT_FACE_SET;

  TYPE IfcLengthMeasure = REAL;
  END_TYPE;

  TYPE IfcDimensionCount = INTEGER;
    WHERE
      WR1 : { 0 < SELF <= 3 };
  END_TYPE;

  ENTITY IfcRepresentationItem
    ABSTRACT SUPERTYPE OF (ONEOF(IfcTopologicalRepresentationItem, IfcGeometricRepresentationItem));
  END_ENTITY;

  ENTITY IfcTopologicalRepresentationItem
    ABSTRACT SUPERTYPE OF (ONEOF(IfcConnectedFaceSet, IfcEdge, IfcFace, IfcFaceBound, IfcLoop, IfcVertex))
    SUBTYPE OF(IfcRepresentationItem);
  END_ENTITY;

  ENTITY IfcConnectedFaceSet
    SUBTYPE OF(IfcTopologicalRepresentationItem);
      CfsFaces : SET [1:?] OF IfcFace;
  END_ENTITY;

  ENTITY IfcFace
    SUBTYPE OF(IfcTopologicalRepresentationItem);
      Bounds : SET [1:?] OF IfcFaceBound;
    WHERE
      WR1 : SIZEOF(QUERY(temp <* Bounds | 'IFC2X2_FINAL.IFCFACEOUTERBOUND' IN TYPEOF(temp))) <= 1;
  END_ENTITY;

  ENTITY IfcFaceBound
    SUBTYPE OF(IfcTopologicalRepresentationItem);
      Bound       : IfcLoop;
      Orientation : BOOLEAN;
    WHERE
      WR1 : 'IFC2X2_FINAL.IFCPOLYLOOP' IN TYPEOF(Bound);
  END_ENTITY;

  ENTITY IfcFaceOuterBound
    SUBTYPE OF(IfcFaceBound);
  END_ENTITY;

  ENTITY IfcLoop
    SUPERTYPE OF (ONEOF(IfcEdgeLoop, IfcPolyloop, IfcVertexLoop))
    SUBTYPE OF(IfcTopologicalRepresentationItem);
  END_ENTITY;

  ENTITY IfcEdgeLoop
    SUBTYPE OF(IfcLoop);
      EdgeList : LIST [1:?] OF IfcOrientedEdge;
    DERIVE
      ne       : INTEGER := SIZEOF(EdgeList);
    WHERE
      WR1 : (EdgeList[1].EdgeStart) :=: (EdgeList[Ne].EdgeEnd);
      WR2 : IfcLoopHeadToTail(SELF);
  END_ENTITY;

  ENTITY IfcOrientedEdge
    SUBTYPE OF(IfcEdge);
      EdgeElement            : IfcEdge;
      Orientation            : BOOLEAN;
    DERIVE
      SELF\IfcEdge.EdgeStart : IfcVertex := IfcBooleanChoose 
                               (Orientation, EdgeElement.EdgeStart, EdgeElement.EdgeEnd);
      SELF\IfcEdge.EdgeEnd   : IfcVertex := IfcBooleanChoose 
                               (Orientation, EdgeElement.EdgeEnd, EdgeElement.EdgeStart);
    WHERE
      WR1 : NOT('IFC2X2_FINAL.IFCORIENTEDEDGE' IN TYPEOF(EdgeElement));
  END_ENTITY;

  ENTITY IfcEdge
    SUBTYPE OF(IfcTopologicalRepresentationItem);
      EdgeStart : IfcVertex;
      EdgeEnd   : IfcVertex;
  END_ENTITY;

  ENTITY IfcVertex
    SUBTYPE OF(IfcTopologicalRepresentationItem);
  END_ENTITY;

  ENTITY IfcVertexPoint
    SUBTYPE OF(IfcVertex);
      VertexGeometry : IfcPoint;
  END_ENTITY;

  ENTITY IfcPoint
    ABSTRACT SUPERTYPE
    SUBTYPE OF(IfcGeometricRepresentationItem);
  END_ENTITY;

  ENTITY IfcCartesianPoint
    SUBTYPE OF(IfcPoint);
      Coordinates : LIST [1:3] OF IfcLengthMeasure;
    DERIVE
      Dim         : IfcDimensionCount := 3;
    WHERE
      WR1 : HIINDEX(Coordinates) >= 2;
  END_ENTITY;

  ENTITY IfcPolyloop
    SUBTYPE OF(IfcLoop);
      Polygon : LIST [3:?] OF IfcCartesianPoint;
    WHERE
      WR21 : SIZEOF(QUERY(Temp <* Polygon | Temp.Dim <> Polygon[1].Dim)) = 0;
  END_ENTITY;

  ENTITY IfcVertexLoop
    SUBTYPE OF(IfcLoop);
      LoopVertex : IfcVertex;
  END_ENTITY;

  ENTITY IfcPlacement
    ABSTRACT SUPERTYPE
    SUBTYPE OF(IfcGeometricRepresentationItem);
    DERIVE
      Dim : IfcDimensionCount := Location.Dim;
  END_ENTITY;

  ENTITY IfcGeometricRepresentationItem
    ABSTRACT SUPERTYPE OF (ONEOF(IfcCurve, IfcDirection, IfcPlacement, IfcSurface, IfcPoint))
    SUBTYPE OF(IfcRepresentationItem);
  END_ENTITY;

  ENTITY IfcDirection
    SUBTYPE OF(IfcGeometricRepresentationItem);
      DirectionRatios : LIST [2:3] OF REAL;
    DERIVE
      Dim             : IfcDimensionCount := HIINDEX(DirectionRatios);
  END_ENTITY;

  ENTITY IfcCurve
    ABSTRACT SUPERTYPE
    SUBTYPE OF(IfcGeometricRepresentationItem);
    DERIVE
      Dim : IfcDimensionCount := IfcCurveDim(SELF);
  END_ENTITY;

  ENTITY IfcBoundedCurve
    ABSTRACT SUPERTYPE
    SUBTYPE OF(IfcCurve);
  END_ENTITY;

  ENTITY IfcSurface
    ABSTRACT SUPERTYPE OF (ONEOF(IfcBoundedSurface, IfcElementarySurface))
    SUBTYPE OF(IfcGeometricRepresentationItem);
  END_ENTITY;

  ENTITY IfcBoundedSurface
    SUBTYPE OF(IfcSurface);
  END_ENTITY;

  ENTITY IfcCurveBoundedPlane
    SUBTYPE OF(IfcBoundedSurface);
      BasisSurface    : IfcPlane;
      OuterBoundary   : IfcCurve;
      InnerBoundaries : SET OF IfcCurve;
    DERIVE
      Dim             : IfcDimensionCount := BasisSurface.Dim;
  END_ENTITY;

  ENTITY IfcPlane
    SUBTYPE OF(IfcElementarySurface);
  END_ENTITY;

  ENTITY IfcElementarySurface
    ABSTRACT SUPERTYPE
    SUBTYPE OF(IfcSurface);
      Position : IfcAxis2Placement3D;
    DERIVE
      Dim      : IfcDimensionCount := Position.Dim;
  END_ENTITY;

  ENTITY IfcAxis2Placement3D
    SUBTYPE OF(IfcPlacement);
      Axis         : OPTIONAL IfcDirection;
      RefDirection : OPTIONAL IfcDirection;
    DERIVE
      P            : LIST [3:3] OF IfcDirection := IfcBuildAxes(Axis, RefDirection);
    WHERE
      WR1 : SELF\IfcPlacement.Location.Dim = 3;
      WR2 : (NOT (EXISTS (Axis))) OR (Axis.Dim = 3);
      WR3 : (NOT (EXISTS (RefDirection))) OR (RefDirection.Dim = 3);
      WR4 : (NOT (EXISTS (Axis))) OR (NOT (EXISTS (RefDirection))) OR (IfcCrossProduct(Axis,RefDirection).Magnitude > 0.0);
      WR5 : NOT ((EXISTS (Axis)) XOR (EXISTS (RefDirection)));
  END_ENTITY;

  ENTITY IfcFaceSurface
    SUBTYPE OF(IfcFace);
      FaceSurface : IfcSurface;
      SameSense   : BOOLEAN;
  END_ENTITY;

  ENTITY fp_represent_polyline
    SUBTYPE OF(IfcBoundedCurve);
  END_ENTITY;

  FUNCTION IfcLoopHeadToTail
  (ALoop : IfcEdgeLoop)
  	: LOGICAL;
       LOCAL
         N : INTEGER;
         P : LOGICAL := TRUE;
       END_LOCAL;
         
         N := SIZEOF (ALoop.EdgeList);
         REPEAT i := 2 TO N;
           P := P AND (ALoop.EdgeList[i-1].EdgeEnd :=:
                       ALoop.EdgeList[i].EdgeStart);
         END_REPEAT;     
         RETURN (P);
  END_FUNCTION;

  FUNCTION IfcCrossProduct
  (Arg1, Arg2 : IfcDirection)
  	: IfcVector;
    LOCAL
      Mag : REAL;
      Res : IfcDirection;
      V1,V2  : LIST[3:3] OF REAL;
      Result : IfcVector;
    END_LOCAL;
    
      IF (NOT EXISTS (Arg1) OR (Arg1.Dim = 2)) OR (NOT EXISTS (Arg2) OR (Arg2.Dim = 2)) THEN
        RETURN(?);
      ELSE
        BEGIN
          V1  := IfcNormalise(Arg1).DirectionRatios;
          V2  := IfcNormalise(Arg2).DirectionRatios;
          Res := IfcRepresentationItem() || IfcGeometricRepresentationItem () 
                 || IfcDirection([(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.DirectionRatios[i]*Res.DirectionRatios[i];
          END_REPEAT;
          IF (Mag > 0.0) THEN
            Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector(Res, SQRT(Mag));
          ELSE
            Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector(Arg1, 0.0);
          END_IF;
          RETURN(Result);
        END;
      END_IF;
  END_FUNCTION;

END_SCHEMA;

Page Operations

Browse Space