API Docs

Class: Apertures

BIM. Apertures

A core class for parametrically generating apertures in elements.

This class provides basic parameters for defining an opening in a wall or slab. Other classes can build in this infrastructure to define additional parameters and generate more detailed and specific parametric aperture forms.

new Apertures( [config] [, typeName])

Creates a new basic opening representation.

Parameters:
Name Type Argument Description
config object <optional>

An optional configuration object.
Properties of config:
Name Type Argument Description
name string <optional>

A human-readable name for this component.
uuid string <optional>

A universally unique identifier of this component.
productRef string <optional>

The product reference number or identifier.
description string <optional>

A brief product or type description.
supplier BIM.Supplier <optional>

An optional supplier details data object.
frameWidth number <optional>

The distance the frame projects into the aperture area from each side in mm, defaults to 2" or 50mm.
frameDepth number <optional>

The thickness of the frame as measured in the direction of wall thickness in mm, defaults to 3" or 75mm.
frameOffset number <optional>

The offset of the frame from path line in the direction of wall thickness in mm, defaults to 0.
typeName string <optional>

An additional parameter typically used by subclasses to set the component type name without modifying the config object.
Author:
  • drajmarsh

Extends

Classes

Void

Members

:string

className <readonly>

The name of the subclass for this object instance.

This name must match the name of this class within the PD.Registry. Thus, the base implementation simply references this.constructor.getClassName() to ensure that this is always the case even for subclasses. As a result, there is rarely any need to override this method.

This property is used when copying, storing and exporting data for subclass instances to ensure that they are recreated as instances of the right class.

Type
  • string
Inherited From:
Overrides:
:string

description

A brief product or type description, defaults to an empty string.

This description is typically used to provide additional information about the product to other team members, such as its reasons for selection. important features, specifications and/or intended use.

Type
  • string
Inherited From:
Overrides:
:string

displayName <readonly>

The name to display for this class within the user interface.

Type
  • string
Inherited From:
Overrides:
:number

frameOffset

The offset of the frame from path line in the direction of wall thickness in mm, defaults to 0.

A value of zero means that the center of the frame will align with the path line of the wall. A positive value will move the frame outwards towards the outer surface, whilst a negative value will move the frame inwards towards the inner surface.

Type
  • number
:number

frameWidth

The distance the frame projects into the aperture area from each side in mm, defaults to 2" or 50mm.

Type
  • number
:string

iconName <readonly>

The name of the SVG icon to associate with this object instance.

This name should match the name of the icon associated with this class within the PD.Registry. Thus, the default implementation simply references this.constructor.getClassName() to ensure that this is always the case, even for subclasses. However, you can override this property if you want a different icon dependant on other properties of the class instance, as shown in the example below.

Type
  • string
Inherited From:
Overrides:
Example
// Overriding the icon name.

MyElements.Table = class extends PD.Base {
    /// ...
    get iconName() {
        if (this.hasRoundTop) return 'MyElements.Table.Round';
        return this.constructor.getClassName();
    };
    /// ...
 };
:boolean

isApertureType <readonly>

A flag identifying this object as an aperture type.

Type
  • boolean
:boolean

isComponent <readonly>

A flag identifying this object as a shared BIM component.

Type
  • boolean
Inherited From:
Overrides:
:boolean

isLocked

Whether or not this component's parameters are fixed.

This property is used by the UI and framework to indicate that the component's parameters are fixed and therefore not editable. It is typically set by a 3rd-party manufacturer or supplier on products that they can only provide in one configuration.

For example, there is no point specifying a particular manufacturer's fridge and then adjusting its width to fit a hole in your cabinetry if that manufacturer cannot actually supply a fridge of that width.

Thus, when this property is true, you will not be able to edit the parameters, but you can always duplicate the component (or its configuration), but without the supplier details if you really do want to modify it.

Type
  • boolean
Inherited From:
Overrides:
:boolean

isOperable <readonly>

A flag indicating whether this component responds to different values of BIM.Aperture#openFraction.

Type
  • boolean
:string

name

A human-readable name for this item instance.

Type
  • string
Inherited From:
Overrides:
:string

productRef

The product reference number or identifier, defaults to an empty string.

The product reference is typically used to store a serial number, model number, SKU or other identifier provided by the manufacturer or supplier to uniquely identify this product.

Type
  • string
Inherited From:
Overrides:
:number

subType <readonly>

An element-specific subtype.

Type
  • number
Inherited From:
Overrides:
:string

supplier

The product supplier/manufacturer, defaults to null.

This property contains details of the supplier or manufacturer of this product or component. Multiple components can share the same supplier instance to avoid unnecessary duplication of data.

Type
  • string
Inherited From:
Overrides:
:string

uuid

A universally unique identifier for the item instance.

Type
  • string
Inherited From:
Overrides:
:object

icon <static>

The icon associated with this class in the PD.Registry.

See PD.Base.icon for more information on this object format.

Type
  • object

Methods

checkDynamicParameter(param, group, host)

Checks the allowable range of element parameter values.

See the PD.Base#checkDynamicParameter method for more details.

Parameters:
Name Type Description
param PD.Parameter

The parameter that is being interactively changed.
group PD.ParamGroup

The group that the dynamic parameter belongs to.
host BIM.Aperture

The host aperture this component is controlling.
Inherited From:
Overrides:
Example
checkDynamicParameter(param, group, host) {

     switch (param.name) {

         case 'height':
             if (param.value < 1.0) param.value = 1.0;
             break;

         case 'width':
         case 'length':
             if (param.value < 100.0) param.value = 100.0;
             if (this.standardBedSize > 0) { // If not custom.
                 group.setParameterValue('standardBedSize', 0);
                 this.standardBedSize = 0; // Make it custom.
             }
             break;

         case 'standardBedSize': {
                 const std_bed = this.getStandardBedSize(Math.round(param.value));
                 if (std_bed != null) {
                     const [ width, length ] = (PD.DIMENSION.useImperial) ? std_bed.sizeImperial : std_bed.sizeMetric;
                     this.width = PD.Utils.toNumber(width, this.width);
                     group.setParameterValue('width', this.width);
                     this.length = PD.Utils.toNumber(length, this.length);
                     group.setParameterValue('length', this.length);
                 }
             } break;

       }

 };

clone()

Creates a copy of this instance with different name and uuid.

Inherited From:
Overrides:
Returns:

Returns a new instance with copied values.

Type
PD.Base | null

computePlanSectionClipperPath(level, aperture)

Generates the outline of the aperture hole in plan-section view.

Parameters:
Name Type Description
level BIM.Level

The level with the section plane.
aperture BIM.Aperture

The aperture this component is controlling.
Returns:

Returns an array of clipper path points.

Type
Array

fromJSON(data)

Safely copy properties from a source object.

See the PD.Base#fromJSON method for more details.

Parameters:
Name Type Description
data object

The source object containing data to copy.
Overrides:
Returns:

Returns this instance to support method chaining.

Type
BIM.Apertures

getAirFlowArea(aperture)

Retrieves the current area of the aperture area through which air can flow.

Parameters:
Name Type Description
aperture BIM.Aperture

The aperture to compute the air flow area.
Returns:

Returns the current air flow area in m2.

Type
number

getDynamicParameters(host)

Provides a list of dynamic parameter groups for this aperture type.

See the PD.Base#getDynamicParameters method for more details.

Parameters:
Name Type Description
host BIM.Aperture

The host aperture this component is controlling.
Inherited From:
Overrides:
Returns:

Returns an array of PD.ParamGroup objects.

Type
Array
Example
getDynamicParameters(host) {
     return [
         new PD.ParamGroup({
             name: 'mainParams',
             title: 'Table Parameters',
             target: this,
             params: [
                 new PD.Parameter({ name: 'height', title: 'Table Height', value: this.height, paramType: PD.ParamType.SmallDistance, description: 'The height from floor level to the top of the table.' }),
                 new PD.Parameter({ name: 'size', title: 'Table Top Size/Diameter', value: this.size, paramType: PD.ParamType.Distance, description: 'The size of the table top when not defined by a closed path.' }),
                 new PD.Parameter({ name: 'thickness', title: 'Table Top Thickness', value: this.thickness, paramType: PD.ParamType.SmallDistance, description: 'The thickness of the table top surface.' }),
                 new PD.Parameter({ name: 'offset', title: 'Offset From Path', value: this.offset, paramType: PD.ParamType.SmallDistance, description: 'The offset distance from the table path.' }),
                 new PD.Parameter({ name: 'swapSides', title: 'Swap Sides', value: this.swapSides, paramType: PD.ParamType.Boolean, description: 'Reverse the direction of the table relative to its path.' }),
                 new PD.Parameter({ name: 'isRound', title: 'Round Table', value: this.isRound, paramType: PD.ParamType.Boolean, description: 'Whether or not the table surface is round.'  }),
             ]
         }),
         new PD.ParamGroup({
             name: 'legParams',
             title: 'Leg Parameters',
             target: this,
             params: [
                 new PD.Parameter({ name: 'legCount', title: 'Number of Legs', value: this.legCount, paramType: PD.ParamType.Integer, description: 'The number of legs on the table.' }),
                 new PD.Parameter({ name: 'legSize', title: 'Leg Size', value: this.legSize, paramType: PD.ParamType.SmallDistance, description: 'The thickness of each leg of the table.' }),
                 new PD.Parameter({ name: 'legInset', title: 'Leg Edge Inset', value: this.legInset, paramType: PD.ParamType.SmallDistance, description: 'The inset distance of each leg from the table edge.' }),
                 new PD.Parameter({ name: 'legOffset', title: 'Leg Edge Offset', value: this.legOffset, paramType: PD.ParamType.Fraction, description: 'The relative distance of the leg along each edge span.' }),
                 new PD.Parameter({ name: 'legSpan', title: 'Max. Distance Between Legs', value: this.legSpan, paramType: PD.ParamType.Distance, description: 'The maximum distance between legs along each edge span.' })
             ]
         })
     ];
 };

getDynamicParametersForHandle(aperture)

Provides a list of dynamic parameter groups for this aperture type's handle.

Parameters:
Name Type Description
aperture BIM.Aperture

The aperture this component is controlling.
Returns:

Returns an array of PD.ParamGroup objects.

Type
Array

getDynamicParametersForPanel(aperture)

Provides a list of dynamic parameter groups for this aperture type's panel.

Parameters:
Name Type Description
aperture BIM.Aperture

The aperture this component is controlling.
Returns:

Returns an array of PD.ParamGroup objects.

Type
Array

getFrameParameterGroup( [aperture] [, title])

Provides a dynamic parameter group for adjusting this type.

See the PD.Base#getDynamicParameters method for more details.

Parameters:
Name Type Argument Description
aperture BIM.Aperture <optional>

The aperture this component is controlling.
title string <optional>

An optional title for the parameter group.
Returns:

Returns a PD.ParamGroup for the panel.

Type
PD.ParamGroup

getLightFlowArea(aperture)

Retrieves the total area of the aperture that is currently open for light to pass though either glazing or void.

Parameters:
Name Type Description
aperture BIM.Aperture

The aperture to compute the light flow area.
Returns:

Returns the current light flow area in m2.

Type
number

getNameAndSupplierParameters()

Provides a list of dynamic parameter groups for the component name, description and supplier.

See the PD.Base#getDynamicParameters method for more details.

Inherited From:
Overrides:
Returns:

Returns an array of PD.ParamGroup objects.

Type
Array

hasMethod(component, methodName)

Determines if this component has a callable method with the given name.

This method is useful for checking if the component has a particular method before attempting to call it, thereby avoiding potential runtime errors. It is used within the framework to check for the presence of life-cycle methods in an element's type component before delegating them.

Parameters:
Name Type Description
component BIM.Component

The component to check.
methodName string

The case-sensitive name of the function/method to check for.
Inherited From:
Overrides:
Returns:

Returns true if the component is valid and has the function name as a method, otherwise false.

Type
boolean

isCompatibleWith(obj)

Determines if this component can be added to the given entity.

Whilst a small number of components may be compatible with multiple entity types, most components are designed to be used only by a specific entity type, and will not allow you to assign them to an incompatible entity.

Parameters:
Name Type Description
obj BIM.ENTITY | BIM.Entity

The entity type or object instance to check for compatibility with.
Inherited From:
Overrides:
Returns:

Returns true if the component can be added to the object, otherwise false.

Type
boolean

rebuild(aperture, view, level)

Rebuilds the geometry of an aperture ready for visualisation.

The job of the rebuild method is to set the apertures's holeProfile and sillProfile, as well as adding jamb and frame geometry to the aperture's shell and glazingPanes objects.

Parameters:
Name Type Description
aperture BIM.Aperture

The aperture component to rebuild.
view PD.ViewData

The view definition to render the model within.
level BIM.Level

The level currently being rebuilt.
Inherited From:
Overrides:
Returns:

Returns this aperture type to support method chaining.

Type
BIM.Apertures

updateDynamicParameters(param, group)

Sets the dynamic parameter value and returns true if it changed.

Most subclasses don't need to override this method as it automatically detects changes and rebuilds the element/component and model when required. However, if you do need to add your own custom logic or intercept the return value, please read the following examples carefully and use whichever best suits your needs.

NOTE: When overriding this method, you may not want to call super.updateDynamicParameters(param, group) as the parent class may have added its own logic that may interfere with what you want to do. Instead, either use the static PD.Base.updateDynamicParametersOnHost method to check if the value changed, or base it on the third example which replicates the code in that static method.

Parameters:
Name Type Description
param PD.Parameter

The dynamic parameter that changed.
group PD.ParamGroup

The group that the dynamic parameter belongs to.
Inherited From:
Overrides:
Returns:

Returns true if the value actually changed.

Type
boolean
Examples
updateDynamicParameters(param, group) {

     /// When you want parent class to use its logic.
     if (super.updateDynamicParameters(param, group)) {
         if (param.name == 'i_am_special') this.doSomethingSpecial();
         return true;
     }

     return false;

 };
updateDynamicParameters(param, group) {

     /// When you don't want parent to handle parameter updates.
     if (PD.Base.updateDynamicParametersOnHost(param, group, this)) {

         /// Invalidate geometry.
         if (this.typeComponent) {
             ++this.typeComponent.updateIndex;
         }

         /// Rebuild element.
         this.hasChanged = true;
         this.update();

         /// Only update site mesh.
         if (this.onlyUsesSiteMesh) {
             const level = this.level;
             if (level) { // Don't trigger whole level update.
                 level.rebuildSiteMesh();
                 PD.GlobalActions.redrawAndUpdateSelection();
                 return false;
             }
         }

         return true;

     }

     return false;

 };
updateDynamicParameters(param, group) {

     /// The following three lines of code replicate
     /// `PD.Base.updateDynamicParametersOnHost()`, which you can
     /// use if you need to access `target` without having to call
     /// `group.getTarget() || this` twice.

     const target = group.getTarget() || this;
     target.checkDynamicParameter(param, group, this);
     if (param.setValueOnHostIfDifferent(target, group, this)) {

         /// You can now use `target`.
         if (target.myOwnMeshThatIsUpdatedDuringRebuild) {

             /// Rebuild element.
             this.hasChanged = true;
             this.update();

             /// If no level meshes or other elements are affected,
             /// simply update the target locally and return false.
             this.myOwnMeshThatIsUpdatedDuringRebuild.update();

             /// Update selection meshes if the
             /// element's highlight geometry changed.
             PD.GlobalActions.updateSelectionMeshes();
             return false;

         }

         return true;

     }

     return false;

 };

addRectangularDoorFrame(coords, shell, width, height, frameWidth, frameDepth, frameHeight, frameOffset [, reverse]) <static>

Add a frame around the top and sides of a door aperture.

     15-------------------------14
   7---------------------------6 |
   | :   10 - - - - - - - - 11 | |
   | : 2-------------------3 : | |
   | : | |                 | : | |
   | : | |                 | : | |
   | : | |                 | : | |
   | : | |                 | : | |
   | 8 | 9 -  -  -  -  -  -|12 |13
   0---1 -  -  -  -  -  -  4---5

The order of vertices is shown in the image above, and the order of facets in the returned array is as follows:

  1. Front face (5,6,7,0,1,2,3,4)
  2. Rear face (8,15,14,13,12,11,10,9)
  3. Bottom-left face (0,8,9,1)
  4. Bottom-right face (4,12,13,5)
  5. Right face (8,0,7,15)
  6. Top face (15,7,6,14)
  7. Left face (5,13,14,6)
  8. Bottom sill/jamb face (1,4,12,9)
  9. Right-inner face (4,3,11,12)
  10. Head-inner face (3,2,10,11)
  11. Left-inner face (2,1,9,10)

Note that the bottom jamb is not part of the frame, but is included here for convenience.

Parameters:
Name Type Argument Description
coords PD.LocalCoordinates

The local coordinate system to use.
shell PD.Shell

The shell to add the frame surfaces to.
width number

The size of opening in the local X axis.
height number

The size of opening in the local Y axis.
frameWidth number

The size of the frame in the local X axis.
frameDepth number

The size of the frame in the local Y axis.
frameHeight number

The size of the frame in the local Z axis.
frameOffset number

The offset of the frame from the path line.
reverse boolean <optional>

Whether or not to flip surface orientations, defaults to false.
Returns:

Returns an array of 11 facets (including the bottom jamb).

Type
Array

addRectangularDoorFrameOnCurve(aperture, shell, width, height, frameWidth, frameDepth, frameHeight, frameOffset [, reverse]) <static>

Add a frame around the top and sides of a door aperture.

     15-------------------------14
   7---------------------------6 |
   | :   10 - - - - - - - - 11 | |
   | : 2-------------------3 : | |
   | : | |                 | : | |
   | : | |                 | : | |
   | : | |                 | : | |
   | : | |                 | : | |
   | 8 | 9 -  -  -  -  -  -|12 |13
   0---1 -  -  -  -  -  -  4---5

The order of vertices is shown in the image above, and the order of facets in the returned array is as follows:

  1. Front face (5,6,7,0,1,2,3,4)
  2. Rear face (8,15,14,13,12,11,10,9)
  3. Bottom-left face (0,8,9,1)
  4. Bottom-right face (4,12,13,5)
  5. Right face (8,0,7,15)
  6. Top face (15,7,6,14)
  7. Left face (5,13,14,6)
  8. Bottom sill/jamb face (1,4,12,9)
  9. Right-inner face (4,3,11,12)
  10. Head-inner face (3,2,10,11)
  11. Left-inner face (2,1,9,10)

Note that the bottom jamb is not part of the frame, but is included here for convenience.

Parameters:
Name Type Argument Description
aperture BIM.Aperture

The aperture to generate the door frame for.
shell PD.Shell

The shell to add the frame surfaces to.
width number

The size of opening in the local X axis.
height number

The size of opening in the local Y axis.
frameWidth number

The size of the frame in the local X axis.
frameDepth number

The size of the frame in the local Y axis.
frameHeight number

The size of the frame in the local Z axis.
frameOffset number

The offset of the frame from the path line.
reverse boolean <optional>

Whether or not to flip surface orientations, defaults to false.
Returns:

Returns an array of 11 facets (including the bottom jamb).

Type
Array

addRectangularFrame(coords, shell, width, height, frameWidth, frameDepth, frameHeight, frameOffset [, reverse] [, glazingShell]) <static>

Adds a simple rectangular frame of the given size to a shell.

     11--------------------------10
    3---------------------------2 |
    | :  15 -  -  -  -  -  - 14 | |
    | : 7-------------------6 : | |
    | : | |                 | : | |
    | : | |                 | : | |
    | : |12-----------------|13 | |
    | : 4-------------------5   | |
    | 8 -  -  -  -  -  -  -  -  | 9
    0---------------------------1

The order of vertices is shown in the image above, and the order of facets in the returned array is as follows:

  1. Front face (0,1,2,3/4,5,7,7)
  2. Rear face (9,8,11,10/13,12,15,14)
  3. Sill - inner face (5,4,12,13)
  4. Right - inner face (6,5,13,14)
  5. Head - inner face (7,6,14,15)
  6. Left - inner face (4,7,15,12)
  7. Bottom - outer face (0,8,9,1)
  8. Right - outer face (1,9,10,2)
  9. Top - outer face (2,10,11,3)
  10. Left - outer face (3,11,8,0)

If the glazingShell parameter is provided, an additional glazing panel will be added to the glazing shell.

Parameters:
Name Type Argument Default Description
coords PD.LocalCoordinates

The local coordinate system to use.
shell PD.Shell

The shell to add the frame surfaces to.
width number

The size of opening in the local X axis.
height number

The size of opening in the local Y axis.
frameWidth number

The size of the left and right frame bars in the local X axis.
frameDepth number

The size of the frame in the local Y axis.
frameHeight number

The size of the bottom and top frame bars in the local Z axis.
frameOffset number

The offset of the frame in the local Y axis.
reverse boolean <optional>

Whether or not to flip surface orientations, defaults to false.
glazingShell boolean <optional>
 null

An optional semi-transparent shell to add a glazing panel to.
Returns:

Returns an array of 10 facets.

Type
Array

addRectangularFrameOnCurve(aperture, shell, width, height, frameWidth, frameDepth, frameHeight, frameOffset [, reverse] [, glazingShell]) <static>

Adds a simple rectangular frame of the given size to a shell.

      2-------------2--------------2
    3-------------3--------------3 |
    | :   6 -  -  - 6 -  -  -  6 | |
    | : 7---------7----------7 : | |
    | : | |                  | : | |
    | : | |                  | : | |
    | : | 5---------5--------| 5 | |
    | : 4---------4----------4   | |
    | 1 -  -  -  -  1  -  -  -  -| 1
    0-------------0--------------0
    |             |              |
  Slice         Slice          Slice
    0.         1...N-2          N-1

The order of vertices is shown in the image above.

If the glazingShell parameter is provided, an additional set of glazing panels will be added to the glazing shell.

Parameters:
Name Type Argument Default Description
aperture BIM.Aperture

The aperture the frame belongs to.
shell PD.Shell

The shell to add the frame surfaces to.
width number

The size of opening in the local X axis.
height number

The size of opening in the local Y axis.
frameWidth number

The size of the left and right frame bars in the local X axis.
frameDepth number

The size of the frame in the local Y axis.
frameHeight number

The size of the bottom and top frame bars in the local Z axis.
frameOffset number

The offset of the frame in the local Y axis.
reverse boolean <optional>

Whether or not to flip surface orientations, defaults to false.
glazingShell boolean <optional>
 null

An optional semi-transparent shell to add a glazing panel to.
Returns:

Returns an array of facets.

Type
Array

addRectangularFrameOperationIndicator(coords, shell, width, height, frameWidth, frameDepth, frameHeight, frameOffset, operation) <static>

Adds operation indicators to a rectangular window panel frame.

     +-----------------+    +-----------------+    +-----------------+
     | +-------------+ |    | +-------------+ |    | +-------------+ |
     | |\           /| |    | | \__         | |    | |             | |
     | | \         / | |    | |     \__     | |    | |     _/      | |
     | |  \       /  | |    | |         \__ | |    | |   _/_____   | |
     | |   \     /   | |    | |         __/ | |    | |    \_       | |
     | |    \   /    | |    | |     __/     | |    | |      \      | |
     | |     \ /     | |    | | __/         | |    | |             | |
     | +------+------+ |    | +-------------+ |    | +-------------+ |
     +-----------------+    +-----------------+    +-----------------+

Indicator lines are added as edges to the given shell.

Parameters:
Name Type Description
coords PD.LocalCoordinates

The local coordinate system to use.
shell PD.Shell

The shell to add the indictor lines to.
width number

The size of opening in the local X axis.
height number

The size of opening in the local Y axis.
frameWidth number

The size of the left and right frame bars in the local X axis.
frameDepth number

The size of the frame in the local Y axis.
frameHeight number

The size of the bottom and top frame bars in the local Z axis.
frameOffset number

The offset of the frame in the local Y axis.
operation BIM.OPERABLE

The window panel operation.
Returns:

Returns an array of 10 facets.

Type
Array.<PD.Polygon>

getClassDescription() <static>

A brief description of this class to accompany its icon.

Returns:

Returns a brief description.

Type
string

getClassName() <static>

The name of this class within the PD.Registry.

See PD.Base.getClassName for more details as this is required for use with the PD.Registry.

Returns:

Returns the registered name of this class.

Type
string

getDisplayName() <static>

The name to display within the user interface.

Returns:

Returns the display name.

Type
string

getHostElementClass() <static>

Retrieves the class of the host element for this component.

See BIM.Component#getHostElementClass for more details on this static method.

Returns:

Returns the element class this component requires as a host.

Type
BIM.Aperture

isCompatibleWith(obj) <static>

Determines if this component can be added to the given object.

Parameters:
Name Type Description
obj BIM.ENTITY | BIM.Entity

The entity type or object to check for compatibility with.
Returns:

Returns true if the component can be added to the object, otherwise false.

Type
boolean

renderDashedDoorSwing(coords, mesh, radius, angle_max) <static>

Add the semi-circular arc of a door swing to the given mesh.

           ..'''||
        .''     ||
       :        ||
 ----+:         ||+---------
     |+         ++|
 ----+:         ||+---------
       :        ||
        '._     ||
           ''.._||
Parameters:
Name Type Description
coords PD.LocalCoordinates

The local coordinates to use.
mesh PD.PolyMesh

The mesh to add geometry to.
radius number

The radius of the door swing.
angle_max number

The maximum door swing angle, in degrees.

subType() <static>

Retrieves the sub-type of opening this class represents.

See BIM.Component#subType for more details on this static method.

Returns:

Returns the sub-type enumerator of this class.

Type
BIM.OPENING