Tool for building a better world.

1. Introduction

1.1. STEP ISO-10303

PIComposer is a STEP ISO-10303 Standard document editor powered by a highly performant EXPRESS document store. To support real-time applications, the document store utilizes its own lossless proprietary binary encoding of EXPRESS data.

Furthermore, to handle models that may not fit into device memory, PIComposer lazy loads all data on demand. EXPRESS models and their entity instances (referred to as instances) are accurately presented in its user interface as trees and directed acyclic graphs.

As a user, it is best to think of PIComposer Community Edition as Excel for BIM, with the difference being that instead of interacting with sheets, rows, columns, and cells, a user works with trees and tree nodes. By utilizing the spatial tree and entity instance detail tree, PIComposer users can interact directly with BIM models. Authoring a BIM model involves adding tree nodes and updating tree node values. Upon each user interaction, SchemaSense, PIComposer’s schema-aware intelligent agent, is active, providing user guidance and a context-sensitive set of menu commands on each node. There are three trees in PIComposer:

  • The spatial tree that manages the model spatial structure

  • The placement tree, which is responsible for instance placement

  • The instance detail tree, which manages instance attributes.

Most of the user’s work involves using the tools and commands of PIComposer to manipulate the above trees.

PIComposer Community Edition is capable of handling any STEP AP through its document store. However, in the context of the community edition, it is specifically restricted to a version of IFC: ifc4x3. For the remainder of this document, our discussion will focus specifically on IFC.

A user of PIComposer Community Edition is assumed to have some knowledge of, or at least a desire to learn, IFC. This is because PIComposer manipulates IFC models by providing user interfaces that directly interact with the content of IFC models, including entities, selects, enums, and more. Without an understanding of IFC, both this document and the PIComposer application itself may be difficult to comprehend.

1.2. Data Storage and Organization

A user’s data is organized within a workspace. A workspace consists of multiple projects owned by the user. Each project is composed of many documents.

Most of the storage in PIComposer is consumed by the documents. There are various types of documents, including templates, scripts, and BIM models.

Within a BIM model, the majority of the storage is devoted to entity instances. Additionally, a model document also stores entity instance’s inverse attributes, tags, search indices, and other supplemental data.

Conceptually, models are documents in a project. However, each BIM model is a document database where documents are stored as binary buffers. These buffers store entity instances. Unlike a line in an ISO-10303 part 21 model file or an element of a typed dataset in part 26 (HDF5 binary encoding), a binary buffer typically contains a logically grouped set of entity instances. Furthermore, if an attribute of an entity instance is itself an entity type, it might be recursively composed within the owning entity instance.

That is, using part 21 and IFCPERSONANDORGANIZATION entity as an illustration, instead of storing instances as:

#1=IFCPERSON($,'John','Doe',$,$,$,$,$);
#2=IFCORGANIZATION($,'Procedural Information System, LLC',$,$,$);
#3=IFCPERSONANDORGANIZATION(#1,#2,$);

structually, a buffer might alternatively store IFCPERSONANDORGANIZATION as:

#3=IFCPERSONANDORGANIZATION(#1=IFCPERSON($,'John','Doe',$,$,$,$,$),#2=IFCORGANIZATION($,'Procedural Information System, LLC',$,$,$),$);

Storing the buffer in the latter structure has many benefits, including:

  • better overall compression

  • reduced number of disk read/write operations

  • reduced number of database queries

  • structure simplicity and easily managed data consistency

The PIComposer command to create the first IFCPERSONANDORGANIZATION structure is set reference command, the second is the create command. Which structure to prefer depends on whether the entity instance stored in an attribute should be shared.

PIComposer stores STRING types using utf8 encoding.

PIComposer organizes BIM model data similar to an Entity Component System (ECS).

Entity Component System

In a typical ECS system:

  • an entity is a object with a unique identifier

  • a component is entity’s associated data

  • a system is the logic operating on entities and their components.

The central elments in a BIM model are instances of a non-abstract IfcProduct subtype; these instances usually appears in the spatial tree. Each of these instance has an immutable 64-bit integer identifier and plays the entity role in a ECS system.

A component is a special type of instance that is a container of a set of IFC instances; it is composition and aggregation of a set of logically related IFC instances. These components include shapes, propertysets, local placement, and a few other types.

A component could be associated to instance either using an instance’s attribute or through a relationship object.

placement component example

A placement component is a IfcLocalPlacement instance comprises of axis instances, position instance, etc. All the data that would completely define IfcLocalPlacement are placed in a single store document. And the placement is associated to an instance using the IfcProduct’s ObjectPlacement attribute.

Only non-abstract entity types could be instantiated as instance.

Currently, a component must be of the following type:

  • IfcShapeRepresentation (shape)

  • IfcLocalPlacement (placement)

  • IfcRelDefinedByType (type)

  • IfcRelDefinedByProperties (propertyset, quantityset)

  • IfcPresentationLayerAssignment (layer)

  • IfcRelAssociatesMaterial (material)

  • Spatial relationship entities:

    • IfcRelAggregates

    • IfcRelContainedInSpatialStructure

    • Other subtype of IfcRelationship

In addition to instances and components, other concrete IFC types could be instantiated into the model as free form instance and will be stored as a document. A good example of such an instance is instance of IfcOwnerHistory.

1.3. Templates

Most BIM modeling tasks in PIComposer, such as creating a model or modeling real-world objects like tables, can be easily accomplished using templates. Templates are a fundamental mechanism for users to configure, enhance, or customize PIComposer.

At its core, a template is a set of pre-programmed instructions to be executed by PIComposer, written in either Dart, C++, or JSON. PIComposer supports multiple types of templates, including:

  • spatial template

  • instance template

    • (simple) template

    • parametric template

    • transform

    • procedural entity

  • propertyset template

  • quantityset template

  • enum template

A spatial template allows users to scaffold an IFC model during the initial creation phase. It defines the initial spatial structure of the model, such as the site, the number of IfcBuildings, and IfcBuildingStoreys. Additionally, a spatial template specifies the relative placement of each spatial element.

Spatial templates are authored using JSON.

When a spatial template is executed, a model is created with a root IfcProject and all the spatial elements specified in the JSON file. The execution also includes the relevant context information, such as the model’s unit system.

In PIComposer, distance measurements are in millimeters, and angle measurements are in radians. Property and quantity values conform to the MKS unit measure system. This convention establishes an implicit context for templates.

Instance templates serve as instance factories, simplifying the creation of instances within a model. There are four different types of instance templates (as mentioned above), and the instances created by these templates must be of the IfcShapeRepresentation type or a subtype of IfcProduct.

A template could be private to a user’s project or be shared in the cloud and be available for all PIComposer users.

A simple template is an extracted representation of a component or instance within the scope of a project. It can be easily reinstantiated in any other model within the same project. Simple templates serve as a basic form of reuse in PIComposer, enabling copy and paste functionality across spaces and time. If the template represents an IfcProduct, it includes the associated shape of the instance.

A parametric template is a simple template that exposes its attriubute and composite instances and their attributes to direct user manipulation. We called the exposed attributes parametrized attributes. The parametrized attributes are configured using JSON.

A transform template is a parametric template that incorporates an associated procedure. This procedure can take a simple template as input and produce a more complex output. PIComposer includes multiple examples of parametric templates, such as a transformation that takes a BREP box as input and generates a frustum as output.

Procedural entity templates are creational procedures that instantiate instances. They are dart or C++ script with a json configuration file. The configuration file specifies the user input parameter and script input parameters. PIComposer provides several examples of procedural entity templates.

Since not all propertyset and quantityset are published within the ifc schema EXPRESS file, these missing propertyset, quantityset, plus user definded propertyset must be configured using templates so that PIComposer could properly instantiate them. These templates are json files. Many examples are provided with the PIComposer release.

1.4. Filters

The ifc4x3 schema has 130 defined types, more than 240 enum types, almost 100 select types, and more than 800 entity types. In a typical IFC office tower model, it is common to have tens of million of entity instances. To analyze and dissect this massive volume and variety of BIM data set, PIComposer provides a multitude of filters.

In a model, instances could be filtered by:

  • instance type

  • instance id and range

  • tag (instance could be tagged and searched)

  • layer

Templates could be filtered by: type and tag.

1.5. 3d Viewer

IFC models are 3d datasets. For the community edition, PIComposer 3d view is provided via integration with web-ifc-viewer from the Ifc.js project.

The source code for the integration is open source, source code is here.

1.6. Support and Bug reporting

To report an issue or request a feature please go to this project’s github portal: picomposer_community_edition and create an issue.

2. Getting Started

PIComposer is a connected desktop system. To access PIComposer’s essential features, users must have access to the PIComposer cloud service. To create an account with the PIComposer cloud service, first, install PIComposer on your desktop.

PIComposer Community Edition is currently available only for Windows. Support for MacOS and Linux will be added in the future.

2.1. Installation

To install PIComposer, first download the installer from Microsoft App Store and follow the App store directions.

After installation, launch PIComposer and initiate the signup workflow by clicking the signup button.

Fill in your email and choose your password.

Read and accept the licensing terms.

Click the signup button.

signup
signup screen

2.2. Confirm email

Confirm your email to complete your signup process, and PIComposer will be ready for use.

confirm email
email confirmation

It might take a few minutes for the confirmation email to be sent. Some email clients might place the confirmation email in the spam folder. If you do not find your confirmation email in your inbox within a few minutes, please check the spam folder.

To quickly to get up and running and viewing a model:

  1. create a project, see Add and Removing a Project.

  2. create a sample model using the procedural sample model template, see here Working with Models

  3. click the view3d button navigationbar show3d button on the Navigation bar to see the sample model in 3d.

3. Workspace and Projects

PIComposer is a multi-user system where each user has their own distinct workspace for organizing projects.

A project is a collection of IFC models and other related documents.

After successful authentication, a user is initially directed to the workspace pane.

workspace
The workspace pane

There are three main user interface components:

  • The project list—​list of user’s project.

  • The navigation bar—​list of commands to access various part of PIComposer.

  • The status bar—​status of active command (progress, success or failure indicators).

3.1. Add and Removing a Project

To add a project, click the add button navigationbar add button.

To remove a project, select it on the project list, click the minus button navigationbar minus button.

Most PIComposer commands are context dependant. The add and minus button, for example, would add or remove a project in a workspace but add and remove a model in the project pane.

The workspace button navigationbar workspace button is the home button. It routes to the workspace pane from anywhere in PIComposer.

The project button navigationbar project button activates the project pane and displays the contents of selected project or the most recently displayed project.

Double clicking on any project on the project list also activates the project pane and displays the project content.

The model button navigationbar model button activates the model pane and displays the last active model content. See the [PIComposer BIM models] section for more detail about how to work with BIM models.

The preference button navigationbar setting button activates the preference page. See the [Preferenes] section for more detail.

The account button navigationbar account button activates the account page. See the User Account section for more detail.

The help button navigationbar help button activates the help popup menu which has two commands 140:

  • documentation—​show PIComposer documentation in a browser

  • about—​show PIComposer license information

PIComposer provides user feedback using the status bar. Depending on the nature of the command, the status shows:

  • A progress bar for long running command

  • Notification of successful completion of a command

  • Error message for failed command

Each type of status can be turned on and off using preferences.

4. Project, Models and Templates

PIComposer manages models and instance templates in a project. Each project has its own document database where model metadata and private instance templates are stored.

Templates within a project are available to all its models.

Users navigate to the project pane from the workspace by either double clicking on an item in project listing or by clicking the project button navigationbar project button to navigate to the selected project.

The project pane has two tabs: model and template. To work with models, activate the model tab.

project model tab
Project pane, model tab

4.1. Working with Models

To add a model, click the navigationbar add button button on the navigation bar. This command routes the user to the model creation page.

project spatial template list
Model creation page

Click on the desired spatial template tile on the template list. Fill in the detail in the model creation dialog then click the dialog ok button button.

model creation dialog
Model creation dialog

To delete a model, select it in the model list, and click the minus navigationbar minus button button.

4.2. Spatial Template

The EXPRESS models are extremely powerful and versatile. Unfortunately, to achieve such versatility, it is extremely verbose. To name just a few instance types that must be included in a bare minuminum valid BIM model:

  • Header objects

  • IfcProject

  • IfcGeometricRepresentationContext

  • IfcUnitAssignment

  • multiple instances of IfcUnit

  • IfcApplication

  • IfcPerson

  • IfcOrganization

  • IfcPersonAndOrganization

  • …​

PIComposer uses spatial templates definition to scaffold a model. A static spatial template is a json file specifying the initial model spatial heiarchy. A example spatial template is listed below:

{
	"schema": "ifc4x3",
	"element": {
		"type": "ifcproject",
		"name": "from_template",
		"children": [
			{
				"type": "ifcsite",
				"name": "bluff",
				"location": [
					0.0,
					0.0,
					0.0
				],
				"children": [
					{
						"type": "ifcbuilding",
						"name": "East Wing",
						"location": [
							0.0,
							0.0,
							0.0
						],
						"children": [
							{
							  "type": "ifcbuildingstorey",
								"name": "first floor",
								"tag" : "floor.1",
								"location": [
									0.0,
									0.0,
									0.0
								]
							},
							{
							  "type": "ifcbuildingstorey",
								"name": "second floor",
								"tag" : "floor.2",
								"location": [
									0.0,
									0.0,
									2300.0
								]
							}
						]
					}
				]
			}
		]
	}
}

The root json object has two properties: * schema—​the schema name of the model, must be ifc4x3 * element—​the json object representing a spatial element in the spatial heiarchy tree. The root instance in the spatial heiarchy must be an IfcProject. The children property of this json object allows us to define the spatial tree recursively.

Each sub-object of the element has might have the following property:

  • type — concrete subtype of IfcSpatialStructureElement, for example, IfcBuilding. This property is mandatory.

  • name — name of the instance, optional

  • tag — enable search by tag, optional

  • description — description, optional

  • reltype — relationship type to parent, defalut to IfcRelAggregates, optional. If not given, PIComposer will deduce the relationship object type from the parent and children type.

  • count—​number of instance to create, default to 1, optional

  • location—​object placement location, optional

  • axis—​object placement axis, optional

  • fefDirection—​object placement refDirection, optional

  • children—​decendants, optional

use the "location" coordinates to set story elevation, like it is done on second floor of the example

When executing a spatial template, PIComposer creates the IfcProject, the necessary headers, contextual objects, and the model’s unit system. PIComposer creates two parallel heiarchy or trees:

  • The spatial tree that defines the logical containment/parent and children relationship

  • placement tree. Child placment is always relative to its containing parent.

Spatial template released with PIComposer are placed in the installation subfolder: picomposer_data/spatial_template/. They are good source of example.

User defined spatial template should be placed in: Users/yourusername/.picomposer_community/picomposer_data/spatial_template/

All spatial templates in spatial_template folders appear in the template list in the model creation page, including user defined ones.

Spatial template could also be procedural, a dart or C++ creational script. The sample template appearing in the template list is such example.

4.3. Working with Instance Template

To access the instance template listing, activate the template tab on the project pane.

project template tab
Project pane, template tab

Instance templates are the fundamental unit of reuse in PIComposer models. They serve as the equivalent of CATIA’s Power Copy, but with simpler creation, enhanced flexibility, and increased power. Furthermore, they can be shared and accessed by all users.

Creating instance templates is straightforward as they are derived from the basic building blocks of a model that a user has already created.

Instance templates offer customization options by adding dynamic behavior to static elements and models. This allows users to manipulate only the essential properties of a component.

They are also extensible by associating them with scripts written in Dart or C++, enabling the transformation of simple components into highly complex ones.

In addition, instance templates can be used as pure component creational procedures in Dart or C++.

4.3.1. Simple Instance Template

Any instance of type IfcShapeRepresentation and IfcProduct subtype in PIComposer can be extracted as a simple template. A template is a grouping of entity instances packaged for reuse in a compatible context. All dependent entity instances, except for a few global context objects, are included in the template. Some templates may contain complex spatial hierarchies, such as an IfcWall template that includes openings, doors/windows, and all related shapes.

A private template is stored in the project store and is available to all models within a project.

An instance template is created from any above mentioned instance via the create template command, see Instance Root Node for detail.

root node create template command
create template

4.3.2. Parametric Template

A parametric template is a variation of a simple template that exposes attributes for direct user manipulation, enabling dynamic transformations of the template. These parametric attributes are specified in a JSON file. Users can input attribute values through a text box in an object creation dialog.

Multiple json files are possible for a given simple template. Each parametric template must have a unique identitier. See the Viewing and Editing Instance Template section for details.

There is a "generated id" command on the root node of a private template to generate unique identifier. This command must be turned on in the preference if you wish to use the command.

We explain the parametric template’s structure by examining the example.

Below is parametric template of a circular extrude where we expose the depth and radius to user input:

{
	"is_procedural": false,
	"interactive": true,
	"template_id": "QK4heQ6jS-ikgAnbBYxEyg",
	"transform_id": "YTtBFTBCSViKoVBsqEhs1w",
	"description": "cylindrical extrude transform",
	"attributes": [
		{
			"value" : {
				"name": "depth",
				"fun_type": "REAL",
				"value": null,
				"type": "RealValue"
			},
			"path":{"type":1,"nodes":[[6,0,0,[8,2495730769]],[1,0,2],[2,0,[7,1494207214]]],"index":[3,null,null,null]}
		},
		{
			"value" : {
				"name": "radius",
				"fun_type": "REAL",
				"value": null,
				"type": "RealValue"
			},
			"path": {"type":1,"nodes":[[6,0,0,[8,2495730769]],[1,0,2],[2,0,[7,1494207214]],[2,0,[5,1936262883]]],"index":[3,null,null,null]}
		}
	],
	"defaults": []
}
  • is_procedural—​always false for a parametric template, no associated procedure.

  • interactive—​should mostly be true, unless the template expect no user input.

  • template_id—​the unique identifier of the template we wish to parematrize.

  • transform_id—​the parametric template identifier.

  • description—​the description of the parametric template. This appears on the template listing.

  • attributes—​the set of parameters for the template.

    • value:

      • name—​the name of the parameter, this will appear in the interactive dialog.

      • fun_type—​the possible types are: REAL, INT64, BOOLEAN

      • value—​the exchanged value of this attribute

      • type—​the type could be: RealValue, IntValue, BoolValue

    • path—​the path location of the attribute. See the Viewing and Editing Instance Template section on how to obtain this value.

  • defaults—​default values for the attributes, used to populate the interactive dialog.

Below is the dialog when user creates an instance using the template.

parametric template instantiation
cylindrical extrude transform

PIComposer places paremetric json configuration files in the installation folder /picomposer_data/template_transform/template_id/

User defined template must be placed in the folder Users/yourusername/.picomposer_community/picomposer_data/template_transform/template_id/

4.3.3. Template Transformation and Procedural Instance

A template transformation is a parametric template associated with a procedure written either in dart or C++.

Procedural Instance is a dart or C++ script that interacts with and updates the model directly.

PIComposer releases many examples of template transformations and procedure instances.

Tooling for creating template transform and procedure instance is not available in PIComposer Community edition.

An instance template is visible to all models in the project and is considered private to the project.

A shared template is a simple template published to the PIComposer Cloud Service and is avaialable to all users.

A user uses a shared template by downloading it into a project’s private template collection.

All templates have a unique identifier for life time management and tracking. Only the shared template author is allowed to remove or update a shared template. A shared template modification is done by re-uploading a private copy.

PIComposer releases many shared templates.

Shared template summary:

  • Shared templates are immutable

  • Updated by the republishing a private copy

  • Update privileges are limited to the owner of the shared template

Since templates are stored in databases, in the cloud or locally on a device, they must be retrieved using database query. PIComposer exposes these query as filters.

To browse the shared library, click the project template share button shared radio button and use the type or tag filter.

When the template tab is activated, PIComposer loads a list of template types, setting it up for the type filter.

When a user clicks the shared button, the list of types is retrieved from the cloud, users might experience some latancy, espeically outside of the western region of USA.

4.3.4. Type Filter

Filters plays an essential role in accessing and using PIComposer’s data content. There are type filters for both entity instances in a model and templates in a project.

project template type filter
Type filter

All type filters function the same way.

To use the type filter, first select the type:

  1. Select a type from the dropdown list

  2. Select custom type text field, and manually key in the type.

  3. To list all, type the word all in the custom text field

Then click on the project template type filter button type filter button.

Type filter on the shared template library is executed on the cloud.

4.3.5. Tag Filter

For search and retrieval purpose, both entity instance and template can be tagged at creation time. Tags are indexed in document stores. A shared template has the same tag as the private copy.

project template tag filter
Tag filter

To apply the tag filter, enter the tag in the textfield and click the project template tag filter button tag filter button.

4.3.6. Viewing and Editing Instance Template

To interact with a template, select it on the template list. All commands related to the loaded template is availiable on the root node of the tree.

Private template command menu

project template ifcproduct command project template ifcshaperepresentation command

  • show 3d—​launch browser and show template in 3d viewer

  • share—​publish private template to PIComposer communal cloud

  • add shape—​add a IfcRepresentationShape to the IfcProduct

  • add representation item—​add a representation item to a IfcRepresenationShape

  • delete—​remove the template from project

  • copy select path—​copy the path of the selected node to clipboard, helpful for creating parametric template

  • copy template id—​copy the current template id to clipboard

  • generate id—​generate a UUID and copy it to clipboard

A template is special kind of instance, it is manipulate like other instances in a model when it comes to its attributes. Each attribute of a private template are mutable like those of an entity instance in a model. For detail on working with instances, see Working with Instance Detail Tree.

Shared templates, private parametric templates, transformation templates and procedure entitys are immutable.

project template readonly command
commands for readonly template

5. PIComposer BIM Model and Entity Instance

A PIComposer model is a collection of entity instances, some of which can be grouped as a collection of related instances, forming a mini-model with an implicit context. Each BIM model in PIComposer has its own database, and each instance is persisted as a document.

In PIComposer, there are two essential organizational concepts that are emphasized for each model: spatial structure and object placement. The spatial structure enriches a BIM model with a logical organizational structure, while object placement defines the physical location of an instance within the model. These concepts are presented as trees in PIComposer.

The spatial tree and the placement tree are managed in parallel, meaning that creating a node in the spatial tree will trigger the corresponding creation of a node in the placement tree.

It’s important to note that the structure of the placement tree is immutable, its structure is by product of the spatial tree structure.

Placement tree display could be turned of by preference

Each instance in the model is visualized as a tree (sometimes you may encounter an acyclic graph) called the instance detail tree. In this tree, each tree node represents either a logical grouping of instances or an attributed node of an instance. The instance detail tree is responsible for managing all additions, modifications, and deletions of instance attributes.

Several components of an instance can be displayed on the instance detail tree, including:

  1. propertyset/quantityset

  2. object placement

  3. placement absolute coordinate

  4. typeproduct

  5. shapes

Each component type display in the detail tree could be turned on/off using user preference.

PIComposer Community Edition is a single document application. To load a model, select a model in the Project pane model listing and click the navigationbar model button model button or simply double click on the item on the model list.

model spatial tab
Model pane, spatial tree

User can return to the last active model by clicking the navigationbar model button model button from any other page of PIComposer.

PIComposer splits model presentation into two areas:

  • the model structure

  • model instance detail

The model structure area comprises of three tabs

  • spatial—​displays the logical spatial tree

  • placement—​displays the phyical placement tree

  • filters—​random instance access using filter and searches, also free form instance creation

5.1. Selection Set

A selection set is an essential component of the PIComposer user interface. Each of the three model panel tabs—spatial, placement, and filter—has its own selection set. Many commands in PIComposer are executed in the context of the current selection set. It allows users to create inter-node links, insert templates into the spatial tree, insert selected nodes into other nodes, and perform various other actions.

5.2. Working with the Spatial Tree

The spatial tree is where the model spatial structure is managed. The commands to manipulate the tree are directly available on the tree node as popup menu items. To see the context-sensitive commands on a tree node, simply right-click on it.

model spatial node command
typical spatial command

All tree commands are context-sensitive, i.e. their availability and actions depend on the node type and the content of the node.

The commands available to the spatial tree nodes are:

  • add child—​add a IfcSpatialStructural element or IfcProduct to the spatial structure.

  • add template child—​instantiate the selected IfcProduct template in the filter tab to the spatial structure.

  • delete child—​delete the select node

  • show propertyset—​show the current node’s propertyset/quantityset in the instance detail tab.

  • show shape—​show the IfcShapeRepresentation of the node

  • show typed—​show the IfcTypeProduct of the node in the detail tab.

  • copy—​copy the current to clipboard

  • paste—​paste the clipboard content as child.

Only leaf nodes can be deleted, except nodes where their children are logically part of the node’s content, such as a wall with child openings or fills.

5.2.1. Add Child

To add a child to the spatial tree, select the parent node, right click on it to activate the node menu, and select the model add child menu item add child menu item. This command creates three sets of information:

  • the IfcProduct instance

  • the shape component and the material for the shape

  • local object placement component

model add product dialog
product creation dialog.

The options on the product tab include:

  1. To specify the IfcProduct type, type it in the custom text box or select it from the dropdown.

  2. To specify the relation of the product to the parent object, select the IfcRelRelation type from the dropdown or leave it at auto to automatically select it.

  3. Tag the instance for search.

model add product shape dialog
prodcut creation dialog IfcProductRepresentation tab

The shape tab adds a IfcShapeRepresentation to the product. The options are:

  1. create shape via a template

  2. create 3 dimensional shape

  3. create 2 dimensional shape

  4. create 1 or 0 dimensional shape

  5. create IfcStyledItem for the shape

Fill in the necessary information on each tab and click OK when done.

If you wish to skip adding IfcShapeRepresentation, leave the type dropdown to 'null'.

If a template is not used when creating IfcShapeRepresenation, only a skeleton of a IfcRepresentationItem is created. Details must be fill out in the Instance Detail Tree.

Adding children using the spatial tree node menu always adds a corresponding placement node to the placement tree. The child is placed relative to the parent.

Adding a child using tree node menu commands creates the desired child, as well as other related nodes such as a child’s placement node, and additionally, multiple inverse links in the database to manage the various relationships between the nodes in different trees. To ensure that the correct model content appears in the trees, it is best to use the available commands.

5.2.2. Add Template As Child

This command uses the filter selection set. To instantiate an IfcProduct template as a child of a spatial node, follow these steps:

  1. activate the template tab

  2. check the template radio button

  3. use the type or tag filter to find the desired template, see the section Working with Instance Template.

  4. select the template

To add a template as child to the spatial structure, select the parent node, right click on it to activate the node menu, and select the model add child template menu item add child template menu item. Enter the necessary information in the template creation dialog if the template is interactive.

5.2.3. Other Spatial Tree Node Commands

The delete child command model delete child menu item deletes the selected node and the corresponding placement node in the placement. If the inverse link count to the shared IfcShapeRepresentation is 0, the IfcShapeRepresentation will be deleted from the model.

The copy command model copy child menu item copies the node to clipboard. Only leaf node can be copy.

Copy command exception: nodes that could be templates are copyable. For exmple an IfcWall with openings and doors/windows are copyable although it has openings as children

The paste command model paste child menu item pastes the content of the clip to the tree.

Unlike template packaging, which do not package IfcTypeProduct, IfcPropertyset components into the template, the copy/paste command copy does since we are pasted into same model context.

The show type command model goto typeproduct menu item shows the IfcTypeProduct componet of an entity in the detail tree.

All the 'show' commands, such as 'show shape', apply the instance ID filter to the targeted component to display the component in the detail tree.

5.3. Working with the Placement Tree

To highlight its importance in the BIM model, PIComposer user interface includes the placement tree.

To access the placement tree, simply activate the placement tab.

model placement tab
The placement tree

TThe placement tree structure is immutable, meaning its structure is created during the creation of the spatial tree. When a spatial node corresponding to a placement is deleted, the placement will be automatically deleted as well.

The only available command for the placement tree is model add goto placed instance menu item, which navigates to the placed instance associated with the IfcLocalPlacement.

While the placement tree itself is immutable, the placement node is mutable. Like all instances, its attributes can be modified using the instance detail tree.

The 'show placed instance' command uses an inverse link to find the placed product instance in the model, selects it in the instance filter, and then shows its content in the detail tree.

The placement tree can be hidden/shown by setting the hide flag in user preference.

5.4. Working with Filters

Filters allow users to quickly search and retrieve items within the model or project. The filter tab serves as the workbench for dealing with free form instances and working with instances outside of the spatial structure framework. There are two types of filters in the model pane: instance filters and template filters.

For details about template filters, refer to the section on Working with Instance Template. In the following section, we will focus on instance filters.

model instance filter
Instance Filter

5.4.1. Instance Type Filter

The basic functionality of the instance type filter is similar to the template Type Filter. However, the instance filter has two additional features:

  • Filter by subtypes: The subtype filter operates in the same way as the Type Filter, but it considers all subtypes of the user-specified type.

  • Create entity instance of the filter type: The instance filter allows users to directly create an entity instance of the selected filter type.

The user input type could be abstract for the subtype filter.

Instance type filter is limited to return 1000 result instances.

5.4.2. Instance Creation

To create instance of the desired type, select the type from the dropdown list and click the create model instance filter add entity button.

To create an instance of type not on the dropdown list, enter the type using the 'custom type' text box. The type user wants to create must not be abstract.

instance type filter create
type filter dropdown

Instances created using the 'create' command via the filter panel will not create any inverse links, unlike when using the spatial tree commands. Users are responsible for managing instance lifecycle and data consistency.

The instance tag filter functions exactly like the tempate tag filter, see Tag Filter.

5.4.3. Instance Id Filter

Instance type filter is based on a list of specific instance id laterals and a list of ranges.

model instance filter instance id example
Instance id Filter

To use the id filter, first enter the search string in the instance id text box. The syntax is a comma separated list of positive integers and a list of integer ranges. A range is a pair of positive integer separated by a dash.

In the example above, we are looking in the ranges 90 to 100, 200 to 210 and the instance ids 2, 45, 10 and 15.

Next click model instance filter instance id the instance id filter button.

Each range is limited to 1000.

5.5. Working with Instance Detail Tree

The STEP ISO-10303 standard is a group of standards including an object model specification using the EXPRESS language.

An object is a collection of attributes. In PIComposer, a representation of an object is referred to as an instance—an instantiation of an entity type.

5.5.1. Instance Detail Tree

According to ISO-10303-11, "EXPRESS data types are classified according to their nature as: simple data types, aggregation data types, constructed data types, named data types, and generalized data types."

The instance detail tree is where PIComposer users interact with instances and their attributes, which are referred to as "entity data types."

model instance detail
Instance detail tree

The instance detail tree is a federated view that displays the instance along with its components. The visibility of components is optional and can be controlled by user preference. The optional nodes in the instance detail tree include:

  • placement

    • absolute coordinates

  • type—​IfcTypeProduct

  • propertyset/quantityset

  • shape—​IfcShapeRepresentation

The model instance show detail topple optional attribute filter, part of SchemaSense system (see SchemaSense and working with Attributes below), hides optional attribute of an instance. This filter is also part of user preference

Like the spatial tree, user modify tree content by operating directly on the tree nodes.

5.5.2. Instance Root Node

Operations that directly affect the basic structure of the node or entity’s components are anchored at the root node. The operations on the root node include:

  • show 3d—​show the instance in 3d. Available if a instance has shape

  • add to layer—​add instance to a layer, available if there is layer in the model and the instance is of type IfcShapeRepresentation

  • clear layer—​remove instance from all layer it is assigned to

  • create template—​create a private template from the instance.

  • add shape—​add a IfcShapeRepresentation component to instance

  • clear shape—​remove all shape. Also, if the reference count of any shape reach zero, it will be removed from model

  • Add RepItem—​add a IfcRepresenationItem to a IfcShapeRepresentation component.

  • add shape to selected—​add selected IfcShapeRepresentation instance to the spatial tree selected node.

  • add type to selected—​add IfcTypeProduct subtype to the selected spatial tree node. The current instance is the selected IfcRelDefinedByType component in the instance filter.

  • add type—​add IfcTyedProduct to instance

  • remove type—​remove instance from IfcRelDefinedByType component

  • add pset—​add IfcRelDefinedByProperties to instance

  • clear pset—​remove all IfcRelDefinedByProperties from instance

  • add pset to selected—​add filter selected IfcRelDefinedByProperties component to the spatial selected node.

  • add template shape to selected—​add template shape to the spatial selected node.

  • delete—​remove the instance

model instance detail root node commands
Typical IfcProduct root node menu items

5.5.3. SchemaSense and working with Attributes

An instance is a collection of attributes. Each attribute has a data type. The basic attribute data types are:

  • number

  • real

  • integer

  • string

  • boolean

  • logical

  • binary

  • aggregation—​collection

  • defined type

  • entity

  • enum

  • select

A defined type is an alias for some already existing underlying type. For example, IfcLogical is a LOGICAL type.

SchemaSense is PIComposer’s context-aware schema guidance and informational system that speeds up instance creation and editing. It consists of three functional components:

  • Filtering of optional attributes: The optional attribute filter model instance show detail topple hides the optional attributes of an instance. This allows users to create a valid instance while omitting optional attributes.

  • Attribute description during mouse hover: When hovering over a tree node, SchemaSense displays the EXPRESS type of the node in the form of a tooltip. If an attribute is null, SchemaSense indicates this to the user.

  • Context-aware schema-based tree node attribute menu: SchemaSense provides a context-aware menu for modifying or adding attributes. This is particularly useful when dealing with complex attribute types (see below) such as entities, collections, selects, and enums. SchemaSense provides dropdown lists or menu items for modifying or adding values to nodes, allowing users to create multiple values for collections, select entity types or enums. It ensures a sensible workflow when creating select attribute types and helps prevent instances with syntactical errors.

PIComposer categorizes attributes into two groups:

  • simple attributes, which consist of single values and require only a single node for user interaction,

  • complex attributes, which consist of multiple values and require a subtree to store their values.

5.5.4. Simple Attributes

The simple type include:

  • number

  • real

  • integer

  • string

  • boolean

  • logical

  • binary

  • defined type, with simple underlining type

  • enum

Numeric types, string and binary are stored in a text box. Boolean, logical, and enums are presented in a dropdown list. In all cases, user interaction is straight forward.

model simple attribute commands
typcal attribute node command

When an attribute has been modified, there are two ways to commit the updates to the data store in PIComposer. You can either right-click on the label of the attribute to access the tree node menu and select the 'save' menu item, or click the 'save' button located at the top-right corner of the detail instance tree interface.

The 'save' button located in the upper right corner of the interface is a batch save button. It allows you to commit all changes made to the detail instance tree to the data store all at once. The attribute node save command is a targeted command; it will only save its change and clear changes to other nodes.

The defined type IfcGloballyUniqueId uses string as its underlying type. Since users may not have access to a UUID generator, PIComposer provides the 'set guid' command. To set a guid attribute, right-click on the label of the attribute and select the 'set guid' command model instance detail set guid.

5.5.5. Complex Attributes

The complex attribute types are:

  • entity

  • select

  • collection

A complex attribute typically requires multiple nodes to represent its value. In particular, when an entity instance is composed in situ, it will occupy a full subtree.

Attribute node commands include:

  • create—​create an entity instance in place

  • set reference—​set attribute value as entity instance reference

  • set reference selected—​set spatial tree entity instance attriubte value to reference the selected instance in instance filter.

  • remove—​remove instance or instance reference from a instance collection attribute

  • show instance—​show attribute instance in detail using instance filter.

  • nullify—​set optional attriubte to null

model instance detail entity attribute commands
typical entity attribute command

Just as there are two ways—​aggregation and composition--to associate one object to another, there are two ways to associate an entity attribute to an entity instance.

5.5.6. A Brief Introduction to Object modeling

As mentioned at the beginning of this chapter, a PIComposer model is a collection of objects. This section introduces some object concepts useful in the use of PIComposer.

According to ChatGTP of OpenAI:

Objects and Object Association

In object-oriented programming, objects are the fundamental building blocks that represent entities in the real world or abstract concepts. They are instances of classes that encapsulate data and behavior. Object association is the concept of connecting objects together to represent relationships between them.

Object association can be implemented using two approaches: composition and aggregation. Both approaches are used to represent different types of relationships between objects.

Object Composition

Object composition is a form of object association where one object contains another object as a part of its state. The contained object cannot exist independently of the container object, and its lifecycle is tied to the container object. This is known as a "has-a" relationship.

For example, a car object may contain an engine object. The engine is a part of the car and cannot exist without it. The car object controls the lifecycle of the engine object, and the engine object cannot exist outside of the car object.

Object Aggregation

Object aggregation is a form of object association where one object uses another object as a part of its functionality. The contained object can exist independently of the container object, and its lifecycle is not tied to the container object. This is known as a "uses-a" relationship.

For example, a car object may use a navigation system object to provide directions to the driver. The navigation system is not a part of the car, and it can exist independently of the car object. The car object does not control the lifecycle of the navigation system object, and the navigation system object can exist outside of the car object.

Difference between Object Composition and Object Aggregation

The key difference between object composition and object aggregation is the lifecycle of the contained object. In object composition, the contained object cannot exist independently of the container object, and its lifecycle is tied to the container object. In object aggregation, the contained object can exist independently of the container object, and its lifecycle is not tied to the container object.

Another difference is the relationship between the container object and the contained object. In object composition, the contained object is a part of the container object, and it is owned by the container object. In object aggregation, the contained object is used by the container object, and it is not owned by the container object.

Conclusion

Object association is a powerful concept in object-oriented programming that allows developers to model relationships between objects. Object composition and object aggregation are two approaches used to represent different types of relationships between objects. It is important to understand the difference between these two approaches to choose the appropriate approach for a given situation.

5.5.7. Object Aggregation and Composition in PIComposer

Aggregation is the default instance-to-instance association in the STEP standard, and it is the only option in the ISO 10303 Part 21 standard. The most important difference between object composition and aggregation is that an aggregated object is potentially shared among many objects, while a composed object is embedded in the parent object.

model object aggregation composition
Anatomy of Aggregation and Composer

In the figure above:

  1. The composite node groups all the shared children within a container object to be referenced.

  2. The IfcCartesianPoint object is an aggregated object referenced by 7 inside the composed IfcPolyloop object.

  3. The composed IfcClosedShell inside an IfcFacetedBrep object.

  4. The cfsfaces attribute of the IfcClosedShell object contains a composed collection of IfcFaces.

  5. Composed IfcFaces.

  6. The polygon attribute of IfcPolyloop, which comprises a collection of aggregated IfcCartesianPoint.

  7. An aggregated IfcCartesianPoint.

  8. The contextofitems attribute of an IfcShapeRepresentation object. It references an IfcGeometricRepresentationContext object in the model.

  • To share an object within a model, create it in the model using the filter panel and share it by aggregation.

  • To share an object within a container object, create it under the composites node and share it by aggregation.

  • To compose an object, use a create/add object command and compose the object in situ. For details, see below.

  • Prefer composition over aggregation whenever possible.

  • To share across model boundaries, create a template.

One way to create an aggregation is use the reference selected instance command. To use the reference selected instance command, follow the steps below:

  1. select the desired reference target in instance filter

  2. right click on the entity attribute node label to activate popup menu

  3. choose model set reference selected command set reference selected menu item

"Reference selected" command will only be available if the selected instance is compatible to the Entity attribute. If attribute is optional, it must be null. To reset to a different reference, nullify first

To set reference without using instance filter, select the model set reference command set reference menu item and enter the target instance id on the dialog.

model set reference dialog
set reference

For a component, as a rule for non-shared attribute instance, the create command is the prefered method when populating entity attribute values. In the case of shared instance in a component, use the add composite command to create the shared instance, see [Component and Composite].

To create attribute instance in place, right click on the attribute label, then select model instance detail create attribute instance command command. If necessary fill in the detail in object creation dialog.

If the type to create has no subtype, the attribute instance is directly created without soliciting input from the user.

5.5.8. Working With Select

A select entity attribute is a single value polymorphic container; it could hold value of any defined type within its specification.

There are three commands for select attributes:

  • nullify—​set optional select attribute to null value

  • create—​create the select object in place.

  • remove—​remove select from a collection of select

model select attribute menu
select attriubte menu

The PIComposer create select user interface is based on two key concepts:

  • the selected type

  • the value of the selected type

To create a select attribute value, select the model create select attribute menu item create select menu item. Fill in the detail in the create select dialog by first specifying the selected type, then value type.

model select create dialog
example of select of a select attribute

5.5.9. Working with Collection

STEP aggregation data types are collections of defined types. Aggregations could contain order or unordered, unique or none-unique values. Aggregation containers include:

  • array—​indexed ordered collection

  • list—​ordered collection

  • bag—​unordered collection

  • set—​unordered and unique valued collection

A collection such as a list could be restricted to unique values by using the keyword UNIQUE. For example, the EXPRESS expression LIST [3:?] OF UNIQUE IfcCartesianPoint; means a list of unique Cartesian points.

PIComposer has a simplified collection data model where aggregation data types are modeled as vectors of defined types. PIComposer also supports multi-dimensional aggregation.

PIComposer users use the following commands to work with collections:

  • add—​add an instance

  • add many—​add multiple instances

  • add reference—​available for entity container only

  • clear list—​empty the collection

When dealing with aggregation types, it is up to the user to manage the attributes' constraints, including uniqueness.

In PIComposer, a collection attribute has its own grouping node where collection commands are anchored.

model collection attribute
Entity collect commands

Each add command activates a dialog box. To add mulitple instances into a collection, right click on the collection, and select the model collection attribute add many command add many command. .Entity collection, add many image::model-collection-attribute-add-many.png[]

Complete the add many command by choosing the desired type and entering instance count.

5.6. Working with Propertyset, QuantitySet and Their Templates

Propertyset and quantityset are packaged in a IfcRelDefinesProperties component. The preferred way to work with IfcRelDefinesProperties is using the following command on the root detail node:

  • add propertyset—​model add properties command add propertyset command

  • add selected propertyset—​model add selected propertyset add selected propertyset.

  • add propertyset to selected—​model add propertyset to selected add propertyset to selected instance (from instance filter).

Excecuting the model add properties command add propertyset command activates the create propertyset dialog. Choose the desired propertyset or quantityset and click OK to complete propertyset creation.

model add propertyset dialog
Create Property dialog

The dropdown in the above dialog lists all property sets and quantity sets known to PIComposer, including those defined in the standard schema as well as those defined by templates.

Ifc4x3 documentation defines a large number (more than 600) of property sets and quantity sets outside of the published schema. PIComposer needs to know their content in order to instantiate them. To configure PIComposer to create these and other user-defined property sets, PIComposer uses templates.

A template is defined using a JSON file.

5.6.1. Propertset Template

A property set is a collection of properties. Each property is an entity type that may have multiple attributes. Let’s dive into the property set template by looking at an abridged example:

{
    "__schema": "ifc4x3",
    "__type": "Pset_SlabCommon",
    "Reference" : {
        "property_type" : "P_SINGLEVALUE",
        "value_type" : "IfcIdentifier"
    },
    "Status" : {
        "property_type" : "P_ENUMERATEDVALUE",
        "value_type": "PEnum_ElementStatus"
    },
	"AcousticRating" : {
        "property_type" : "P_SINGLEVALUE",
        "value_type": "IfcLabel"
    },
	"PitchAngle" : {
        "property_type" : "P_SINGLEVALUE",
        "value_type": "IfcPlaneAngleMeasure"
    },
}

The first two template json properties provide header information:

  • __schema—​it must be ifc4x3

  • __type—​the propertyset type, it must be prefix with Pset_xxx

The remaining properties are property definition for the prepertyset.

Each property has a name, a property_type, and a value_type. In the example above for the first property we have:

  • name—​Reference

  • property_type—​P_SINGLEVALUE

  • value_type—​IfcIdentifier

name is the name of the proerpty.

The value of property_type comes for the standard enum IfcSimplePropertyTemplateTypeEnum. The possible property_type values and their corresponding IfcProperty are:

  • P_SINGLEVALUE—​IfcPropertySingleValue

  • P_ENUMERATEDVALUE—​IfcPropertyEnumeratedValue

  • P_BOUNDEDVALUE—​IfcPropertyBoundedValue

  • P_LISTVALUE—​IfcPropertyListValue

  • P_TABLEVALUE—​IfcPropertyListValue

  • P_REFERENCEVALUE—​IfcPropertyListValue

Every value_type is a ifc defined type.

propertyset templates are stored in the folder /picomposer_data/propertyset_template

To create user-defined property sets at runtime without using templates, use the "Add Property Set" command to create an IfcPropertySet, and then add any desired IfcProperty to the model.

5.6.2. Quantityset Template

A quantityset is a collection of quantity. A quantity is a subtype of IfcPhysicalSimpleQuantity that has a numeric attribute. Like other templates, quantityset template specification are json files. Below is a full example:

{
    "__schema": "ifc4x3",
    "__type": "Qto_BeamBaseQuantities",
    "Length":  "Q_LENGTH",
    "CrossSectionArea":  "Q_AREA",
	"OuterSurfaceArea":  "Q_AREA",
	"GrossSurfaceArea":  "Q_AREA",
	"NetSurfaceArea":  "Q_AREA",
	"GrossVolume" : "Q_VOLUME",
	"NetVolume" : "Q_VOLUME",
	"GrossWeight" : "Q_WEIGHT",
	"NetWeight" : "Q_WEIGHT"
}

In the json file, first comes the header, which include the properties:

  • __schema—​must be ifc4x3

  • _type—​the quantityset name, must be prefixed with Qto

The remaining json properties are a list of quantities which has name and type. The possible types and their corresponding entity type are:

  • Q_LENGTH—​IfcQuantityLength

  • Q_AREA—​IfcQuantityArea

  • Q_VOLUME—​IfcQuantityVolume

  • Q_COUNT—​IfcQuantityCount

  • Q_WEIGHT—​IfcQuantityWeight

  • Q_TIME—​IfcQuantityTime

Quantityset templates are stored in the folder /picomposer_data/quantityset_template

To create user defined quantitysets at runtime without using templates, use the add propertyset command to create IfcElementQuantity and manually add any IfcPhysicalSimpleQuantity subtype.

5.7. Working with layers

Layers are commonly used in CAD systems for grouping instances and controlling their visibility. In the IFC standard, the corresponding concept is embodied in the IfcPresentationLayerAssignment entity.

Only component of type IfcShapeRepresentation can be assigned to a layer in PIComposer. However, instances could be filtered by layer indirectly by its association to a shape, see Layer Filter

To setup a layer, first create a IfcPresentationLayerAssignment instance using the instance filter create command.

model instance filter create command
create command

To add layers to an IfcShapeRepresentation component, use the model add to layer command add to layer command.

add layer dialog

image::model-add-to-layer-dialog.png

In the add layer dialog, select the desired layer from the dropdown list.

5.7.1. Layer Filter

A layer provides a grouping of IfcShapeRepresentation components. A layer filter allows for quick access to this grouping. Optionally, instead of listing the shape components, users may choose to list the instances associated with the grouped shapes.

model layer filter
layer filter

To use the layer filter, select the layer from the dropdown list, and press the model filter by layer command filter by layer command.

The filtered result type is controlled by preference.

PIComposer does not show the layer filter if the model does not has any IfcPresentationLayerAssignment instance.

5.8. Ifc Exporting and 3d Viewer

To export models to ifc, click the navigationbar export model button button on the navigation bar. The exported model is saved to user’s download folder with the the file name "modelId.ifc".

To view a model in 3d view, click show the show 3d navigationbar show3d button button on the navigation bar. This will kick start the export of the model to part21. When the export is completed, the web 3d viewer will be launched.

Both commands—​export and view model—​are background tasks. User may continue working in parallel while the command is running.

6. Preferences

User interface customization is done using the preference pane. The preference setting options are grouped into major sections. Activate the preference pane by clicking the preference command button.

preference
Preference Pane

6.1. Status Displays

Status dispay gives feedback of success or failure to user issued commands, and for long running commands, a progress bar. The options are:

  • show notification—​show notification when user command is completed (error message if completed in failure).

  • show progress bar—​show progress bar for long running command.

command status
Command status

6.2. Model Page Options

The model page’s main function is to display model structural information. PIComposer displays two structural elements of a model: the logical object spatial heiarchy and the phyical object placement heiarchy. To underscore placement’s importance, it has its own dedicate optionally display as a tree.

  • show placement tree—​hide show placement tree in the model page.

placement tree option
placement tree option on

6.3. Instance Detail options

Users most likely spend more time on the instance tree than any other part of PIComposer’s user interface. In addition to the instance attributes, the instance tree may optionally show its related components—​shapes, propersets etc—​allowing a user to manipulate an instance and its related component centrally. The options are:

  • show optional attributes—​show all attributes (including optional ones) in instance tree. Turn this off when it is desirable to create a valid instance quickly and make sure only required attributes are valid.

  • show placement—​option to show local placement component in instance tree.

  • show absolute coordinate—​show computed absolute coordinate.

  • show shape—​show IfcShapeRepresentation components in instance tree.

  • show propertyset—​show instance’s propertyset/quantityset as IfcRelDefinesByProperties components.

  • show type—​show IfcRelDefinesByType component in instance tree.

instance detail options
Instance Detail

6.4. Layer Filter options

Layer filter is a object grouping mechanism useful in managing large CAD data sets and is a feature found on all main stream CAD system. PIComposer’s layer filter system is configured by the layer filter options, and these options are:

  • show layer filter—​show layer filter when model contains at least one layer (IfcPresentationLayerAssignment).

    • show product associated to the layer assigned IfcShapeRepresentation.

6.5. Spatial Tree Node Command Options

PIComposer provides model navigation through the use the spatial tree. Moreover, the spatial tree privides context switching between an instance and its components through a series of command taking advantage of the instance filter. By isolating a component in the instance filter, a component could easily be shared among instances.

  • show Shape detail—​enable show shape command in the spatial tree. The command show the entity’s IfcShapeRepresentation component in the detail tree.

  • show propertyset detail—​enable show propertyset command in the spatial tree. The command show the entitys’s IfcReldefinesproperties in the instance filter.

  • show shape detail—​enable show shape detail command on the spatial tree when entity has shape. This provides a short cut to share shape as mapped items among instances.

  • show propertyset detail—​enable show propertyset detail command on the spatial tree when entity has propertyset.

  • show type detail—​enable show type detail command on the spatial tree when entity has IfcReldefinesByType

6.6. Create Command options

One way to create an instance in the model is using the create command in the filter tab in the model page. Some entity types correspond to component entity types. Thus it is conveneint to create such entity using the component creation work flow. The follwing options activate just such a work flow:

  • show shape create dialog—​show the shape creation dialog when creating a IfcShapeRepresentation in the instance filter.

  • show propertyset create dialog—​show propertyset create dialog when create IfcRelDefinesProperties in the instance filter

  • show type create dialog—​show type create dialog when creating IfcRelDefinesByTypes in the instance filter

  • show create style dialog—​show type create dialog when creating IfcStyledItem

6.7. Private Template Listing options

To hide a template where there are transform of a given template, set the:

  • show template and transform

option to false.

6.8. Private Template Root Node Command options

Options in this section enable commands for authoring instance templates. These are:

  • copy attribute path—​enable copy attribute path command in the template filter where the template type is private

  • copy template id—​enable copy template id command in the template filter where the template type is private

  • guid generator—​enable clipboard guid generation command

6.9. login options:

Login options toggles the persistents of user login information.

  • remember email—​save user email and use it for the next login attempt

  • remember password—​save user password and use it for the next login attempt

7. User Account

The User Account page summarized a user’s account information as it is known to PIComposer. User account information is stored in PIComposer Cloud Service.

Users sign out of current PIComposer sessions and update user account information in the user acccount page.

account pane
User Account

There are three commands:

  • update—​update user information

  • upload—​upload user avatar

  • sign out—​sign out of current user session