IModel

class IModel()

Methods


Methods

_allowNodeDeletion

IModel._allowNodeDeletion(nodeId)
Arguments:
Return type:

void

_firstAssemblyDataHeader

IModel._firstAssemblyDataHeader()
Return type:AssemblyDataHeader() | null

_gatherInstanceIncsFromNodeIds

IModel._gatherInstanceIncsFromNodeIds(nodeIds[, allowedTypes])
Arguments:
Return type:

InstanceIncs

_getModelStructure

IModel._getModelStructure()
Return type:IModelStructure()

_getNodeFromInstanceInc

IModel._getNodeFromInstanceInc(markNodeLoadedIfCreated, inclusionKey, instanceKey, isOutOfHierarchy)
Arguments:
  • markNodeLoadedIfCreated (boolean()) – None
  • inclusionKey (InclusionKey()) – None
  • instanceKey (InstanceKey()) – None
  • isOutOfHierarchy (boolean()) – None
Return type:

NodeId

_hwfAwaitAssemblyTreeReady

IModel._hwfAwaitAssemblyTreeReady()
Return type:Promise <void>

_preventMeshDeletion

IModel._preventMeshDeletion(meshId)
Arguments:
Return type:

void

_preventNodeDeletion

IModel._preventNodeDeletion(nodeId)
Arguments:
Return type:

void

_setDefaultView

IModel._setDefaultView(view)
Arguments:
Return type:

void

_setInstanceModifier

IModel._setInstanceModifier(instanceModifier, nodeIds, value, allowedTypes)
Arguments:
Return type:

void

_setModelStructure

IModel._setModelStructure(modelStructure)
Arguments:
Return type:

void

_setNodesMatrices

IModel._setNodesMatrices(nodeIds, matrices[, setAsInitial])
Arguments:
  • nodeIds ([NodeId]) – None
  • matrices ([Matrix]()) – None
  • setAsInitial (boolean()) – optional None
Return type:

Promise <void>

activateCadConfiguration

IModel.activateCadConfiguration(nodeId[, view])
Arguments:
Return type:

Promise <void>

activateCadView

IModel.activateCadView(nodeId[, duration[, massageCamera[, view]]])
Arguments:
  • nodeId (NodeId) – None
  • duration (number()) – optional None
  • massageCamera (boolean()) – optional None
  • view (IView()) – optional None
Return type:

Promise <void>

activateDefaultCadConfiguration

IModel.activateDefaultCadConfiguration([fitNodes[, view]])
Arguments:
  • fitNodes (boolean()) – optional None
  • view (IView()) – optional None
Return type:

Promise <void>

activateDefaultCadView

IModel.activateDefaultCadView([duration[, massageCamera[, view]]])
Arguments:
  • duration (number()) – optional None
  • massageCamera (boolean()) – optional None
  • view (IView()) – optional None
Return type:

Promise <void>

addPropertyToNode

IModel.addPropertyToNode(id, propertyName, propertyValue, propertyUnit)
Arguments:
  • id (NodeId) – None
  • propertyName (string()) – None
  • propertyValue (string()) – None
  • propertyUnit ([UnitElement]()) – None
Return type:

boolean

cadConfigurationsEnabled

IModel.cadConfigurationsEnabled()
Return type:Promise <boolean>

clear

IModel.clear()
Return type:Promise <void>

clearNodeFaceVisibility

IModel.clearNodeFaceVisibility(id)
Arguments:
Return type:

void

clearNodeLineVisibility

IModel.clearNodeLineVisibility(id)
Arguments:
Return type:

void

clearNodePointVisibility

IModel.clearNodePointVisibility(id)
Arguments:
Return type:

void

computeMinimumBodyBodyDistance

IModel.computeMinimumBodyBodyDistance(partId1, partId2)
Arguments:
Return type:

Promise <FaceFaceDistanceItem()>

computeMinimumFaceFaceDistance

IModel.computeMinimumFaceFaceDistance(partId1, faceId1, partId2, faceId2)
Arguments:
  • partId1 (PartId) – None
  • faceId1 (number()) – None
  • partId2 (PartId) – None
  • faceId2 (number()) – None
Return type:

Promise <FaceFaceDistanceItem()>

computeMinimumFaceLineDistance

IModel.computeMinimumFaceLineDistance(partId, faceId, ray)
Arguments:
  • partId (PartId) – None
  • faceId (number()) – None
  • ray (Ray()) – None
Return type:

Promise <FaceFaceDistanceItem()>

computeMinimumFaceRayDistance

IModel.computeMinimumFaceRayDistance(partId, faceId, ray)
Arguments:
  • partId (PartId) – None
  • faceId (number()) – None
  • ray (Ray()) – None
Return type:

Promise <FaceFaceDistanceItem()>

createAndAddRepresentationItem

IModel.createAndAddRepresentationItem(partNodeId[, repItemId])
Arguments:
  • partNodeId (PartId | undefined | null) – None
  • repItemId (NodeId | null) – optional None
Return type:

NodeId | null

createCadView

IModel.createCadView(nodeId, viewName, camera[, pmiIds[, nodesToShow[, nodesToHide[, nodeIdsAndLocalTransforms[, cuttingPlane[, meshInstanceData]]]]]])
Arguments:
  • nodeId (NodeId) – None
  • viewName (string()) – None
  • camera (Camera()) – None
  • pmiIds ([PmiId] | null) – optional None
  • nodesToShow ([NodeId] | null) – optional None
  • nodesToHide ([NodeId] | null) – optional None
  • nodeIdsAndLocalTransforms ([(NodeId, Matrix)] | null) – optional None
  • cuttingPlane (Plane | null) – optional None
  • meshInstanceData (MeshInstanceData() | null) – optional None
Return type:

CadViewId | null

createImage

IModel.createImage(primaryImage[, thumbnailImage])
Arguments:
Return type:

Promise <ImageId>

createMesh

IModel.createMesh(meshData[, config])
Arguments:
  • meshData (MeshData()) – None
  • config (function()) – optional None
Return type:

Promise <MeshId>

createMeshInstance

IModel.createMeshInstance(data[, parentNodeId[, preventFromResetting[, isOutOfHierarchy]]])
Arguments:
  • data (MeshInstanceData()) – None
  • parentNodeId (NodeId | null) – optional None
  • preventFromResetting (boolean | null()) – optional None
  • isOutOfHierarchy (boolean | null()) – optional None
Return type:

Promise <NodeId>

createNode

IModel.createNode(parentNodeId, nodeName[, nodeId[, localMatrix[, visibility[, measurementUnit]]]])
Arguments:
  • parentNodeId (NodeId | undefined | null) – None
  • nodeName (string()) – None
  • nodeId (NodeId | null) – optional None
  • localMatrix (Matrix | null()) – optional None
  • visibility (boolean | null()) – optional None
  • measurementUnit (number | null()) – optional None
Return type:

NodeId

createPart

IModel.createPart([nodeId])
Arguments:
  • nodeId (NodeId | null) – optional None
Return type:

PartId

createPmiInstance

IModel.createPmiInstance(data, pmiType, pmiSubType, refOnTopoItems[, parentNodeId])
Arguments:
Return type:

Promise <PmiId>

deleteImages

IModel.deleteImages(imageIds)
Arguments:
Return type:

Promise <void>

deleteMeshInstances

IModel.deleteMeshInstances(nodeIds)
Arguments:
Return type:

Promise <void>

deleteMeshes

IModel.deleteMeshes(ids)
Arguments:
Return type:

Promise <void>

deleteNode

IModel.deleteNode(id)
Arguments:
Return type:

Promise <void>

getAbsoluteRootNode

IModel.getAbsoluteRootNode()
Return type:NodeId

getActiveCadConfiguration

IModel.getActiveCadConfiguration()
Return type:NodeId | null

getAssociatedModelKey

IModel.getAssociatedModelKey(nodeId)
Arguments:
Return type:

Promise <ModelKey | null>

getBimIdConnectedElements

IModel.getBimIdConnectedElements(node, bimId, type)
Arguments:
Return type:

function

getBimIdFromNode

IModel.getBimIdFromNode(id)
Arguments:
Return type:

BimId | null

getBimIdRelatedElements

IModel.getBimIdRelatedElements(node, bimId, type)
Arguments:
Return type:

[BimId]

getBimIdRelatingElements

IModel.getBimIdRelatingElements(node, bimId, type)
Arguments:
Return type:

[BimId]

getBimIdsFromGenericId

IModel.getBimIdsFromGenericId(ifcGuid)
Arguments:
Return type:

[BimId]

getBimInfoFromBimId

IModel.getBimInfoFromBimId(node, bimId)
Arguments:
Return type:

function

getBranchVisibility

IModel.getBranchVisibility(id)
Arguments:
Return type:

BranchVisibility

getCadConfigurations

IModel.getCadConfigurations()
Return type:IdStringMap()

getCadViewConfiguration

IModel.getCadViewConfiguration(cadViewNodeId)
Arguments:
  • cadViewNodeId (NodeId) – None
Return type:

NodeId | null

getCadViewMap

IModel.getCadViewMap()
Return type:Map <NodeId, string>

getCadViewPmis

IModel.getCadViewPmis(nodeId)
Arguments:
Return type:

[PmiId]

getDataFromIds

IModel.getDataFromIds(ids)
Arguments:
  • ids (DataIds()) – None
Return type:

Promise <[Uint8Array]>

getDefaultCadConfiguration

IModel.getDefaultCadConfiguration()
Return type:NodeId | null

getDefaultCadView

IModel.getDefaultCadView()
Return type:NodeId | null

getEdgeAttributes

IModel.getEdgeAttributes(id, edgeIndex)
Arguments:
  • id (NodeId) – None
  • edgeIndex (number()) – None
Return type:

Promise <SubentityAttributes() | null>

getEdgeCount

IModel.getEdgeCount(id)
Arguments:
Return type:

Promise <number>

getEdgeProperty

IModel.getEdgeProperty(id, edgeId)
Arguments:
  • id (NodeId) – None
  • edgeId (number()) – None
Return type:

Promise <Edge | null>

getFaceAttributes

IModel.getFaceAttributes(id, faceIndex)
Arguments:
  • id (NodeId) – None
  • faceIndex (number()) – None
Return type:

Promise <SubentityAttributes() | null>

getFaceCount

IModel.getFaceCount(id)
Arguments:
Return type:

Promise <number>

getFaceProperty

IModel.getFaceProperty(id, faceId)
Arguments:
  • id (NodeId) – None
  • faceId (number()) – None
Return type:

Promise <Face | null>

getFilterName

IModel.getFilterName(filterId)
Arguments:
Return type:

FilterName | null

getFilters

IModel.getFilters()
Return type:Map <FilterId, FilterName>

getFiltersWithNode

IModel.getFiltersWithNode(nodeIdSearched)
Arguments:
  • nodeIdSearched (NodeId) – None
Return type:

[FilterId]

getGenericIdFromBimId

IModel.getGenericIdFromBimId(node, bimId)
Arguments:
Return type:

GenericId | null

getGenericTypeIdMap

IModel.getGenericTypeIdMap()
Return type:Map <GenericType, Set <NodeId>>

getGenericTypes

IModel.getGenericTypes()
Return type:[GenericType]

getLayerIdsFromName

IModel.getLayerIdsFromName(name)
Arguments:
Return type:

[LayerId] | null

getLayerName

IModel.getLayerName(layerId)
Arguments:
Return type:

LayerName | null

getLayers

IModel.getLayers()
Return type:Map <LayerId, LayerName>

getLooseBounding

IModel.getLooseBounding()
Return type:Promise <Box>

getLowestAvailableNodeId

IModel.getLowestAvailableNodeId()
Return type:NodeId

getMeshIds

IModel.getMeshIds(ids)
Arguments:
Return type:

Promise <[MeshId]>

getMetallicRoughness

IModel.getMetallicRoughness(nodeIds)
Arguments:
Return type:

Promise <[MetallicRoughnessValue()]>

getModelBounding

IModel.getModelBounding(ignoreInvisible, includeExcluded[, tightBounding])
Arguments:
  • ignoreInvisible (boolean()) – None
  • includeExcluded (boolean()) – None
  • tightBounding (boolean()) – optional None
Return type:

Promise <Box>

getModelFileNameFromNode

IModel.getModelFileNameFromNode(id)
Arguments:
Return type:

string | null

getModelFileTypeFromNode

IModel.getModelFileTypeFromNode(id)
Arguments:
Return type:

FileType | null

getNodeCappingMeshData

IModel.getNodeCappingMeshData(id)
Arguments:
Return type:

Promise <MeshDataCopy() | null>

getNodeChildren

IModel.getNodeChildren(id[, all])
Arguments:
  • id (NodeId) – None
  • all (boolean()) – optional None
Return type:

[NodeId]

getNodeColorMap

IModel.getNodeColorMap(id, elementType)
Arguments:
Return type:

Promise <Map <NodeId, Color>>

getNodeEffectiveFaceColor

IModel.getNodeEffectiveFaceColor(id, faceIndex[, view])
Arguments:
  • id (NodeId) – None
  • faceIndex (number()) – None
  • view (IView()) – optional None
Return type:

Promise <Color | null>

getNodeEffectiveLineColor

IModel.getNodeEffectiveLineColor(id, lineIndex[, view])
Arguments:
  • id (NodeId) – None
  • lineIndex (number()) – None
  • view (IView()) – optional None
Return type:

Promise <Color | null>

getNodeEffectivePointColor

IModel.getNodeEffectivePointColor(id, pointIndex[, view])
Arguments:
  • id (NodeId) – None
  • pointIndex (number()) – None
  • view (IView()) – optional None
Return type:

Promise <Color | null>

getNodeExchangeId

IModel.getNodeExchangeId(id)
Arguments:
Return type:

ExchangeId | null

getNodeFaceColor

IModel.getNodeFaceColor(id, faceIndex)
Arguments:
  • id (NodeId) – None
  • faceIndex (number()) – None
Return type:

Promise <Color | null>

getNodeFaceHighlighted

IModel.getNodeFaceHighlighted(id, faceIndex)
Arguments:
  • id (NodeId) – None
  • faceIndex (number()) – None
Return type:

Promise <boolean>

getNodeGenericId

IModel.getNodeGenericId(id)
Arguments:
Return type:

GenericId | null

getNodeGenericType

IModel.getNodeGenericType(id)
Arguments:
Return type:

GenericType | null

getNodeIdFromBimId

IModel.getNodeIdFromBimId(node, bimID)
Arguments:
Return type:

NodeId | null

getNodeIdFromScInstanceKey

IModel.getNodeIdFromScInstanceKey(inclusionKey, instanceKey)
Arguments:
  • inclusionKey (InclusionKey()) – None
  • instanceKey (InstanceKey()) – None
Return type:

NodeId | null

getNodeIdOffset

IModel.getNodeIdOffset(id)
Arguments:
Return type:

NodeIdOffset

getNodeIdsByGenericIds

IModel.getNodeIdsByGenericIds(genericIds)
Arguments:
Return type:

[NodeId]

getNodeLayerId

IModel.getNodeLayerId(id)
Arguments:
Return type:

LayerId | null

getNodeLineColor

IModel.getNodeLineColor(id, lineIndex)
Arguments:
  • id (NodeId) – None
  • lineIndex (number()) – None
Return type:

Promise <Color | null>

getNodeLineHighlighted

IModel.getNodeLineHighlighted(id, lineIndex)
Arguments:
  • id (NodeId) – None
  • lineIndex (number()) – None
Return type:

Promise <boolean>

getNodeMatrix

IModel.getNodeMatrix(id)
Arguments:
Return type:

Matrix

getNodeMeshData

IModel.getNodeMeshData(id)
Arguments:
Return type:

Promise <MeshDataCopy()>

getNodeName

IModel.getNodeName(id)
Arguments:
Return type:

string | null

getNodeNetMatrix

IModel.getNodeNetMatrix(id)
Arguments:
Return type:

Matrix

getNodeParent

IModel.getNodeParent(id)
Arguments:
Return type:

NodeId | null

getNodePointColor

IModel.getNodePointColor(id, pointIndex)
Arguments:
  • id (NodeId) – None
  • pointIndex (number()) – None
Return type:

Promise <Color | null>

getNodePointHighlighted

IModel.getNodePointHighlighted(id, pointIndex)
Arguments:
  • id (NodeId) – None
  • pointIndex (number()) – None
Return type:

Promise <boolean>

getNodeProperties

IModel.getNodeProperties(id[, computeFromChildren])
Arguments:
  • id (NodeId) – None
  • computeFromChildren (boolean()) – optional None
Return type:

Promise <StringStringMap() | null>

getNodeRealBounding

IModel.getNodeRealBounding(id[, view])
Arguments:
Return type:

Promise <Box>

getNodeType

IModel.getNodeType(id)
Arguments:
Return type:

NodeType

getNodeUnitMultiplier

IModel.getNodeUnitMultiplier(id)
Arguments:
Return type:

number

getNodeUserData

IModel.getNodeUserData(id, index)
Arguments:
Return type:

Uint8Array

getNodeUserDataIndices

IModel.getNodeUserDataIndices(id)
Arguments:
Return type:

[UserDataIndex]

getNodeVisibility

IModel.getNodeVisibility(id)
Arguments:
Return type:

boolean

getNodesAmbientColor

IModel.getNodesAmbientColor(ids)
Arguments:
Return type:

Promise <[any]>

getNodesBounding

IModel.getNodesBounding(ids[, config])
Arguments:
Return type:

Promise <Box>

getNodesByGenericType

IModel.getNodesByGenericType(genericType)
Arguments:
Return type:

Set <NodeId> | null

getNodesCappingMeshData

IModel.getNodesCappingMeshData(nodeIds)
Arguments:
Return type:

Promise <[MeshDataCopy()]>

getNodesCullingVectors

IModel.getNodesCullingVectors(nodeIds)
Arguments:
Return type:

Promise <[CullingVector()]>

getNodesEffectiveAmbientColor

IModel.getNodesEffectiveAmbientColor(ids)
Arguments:
Return type:

Promise <[Color]>

getNodesEffectiveEmissiveColor

IModel.getNodesEffectiveEmissiveColor(ids)
Arguments:
Return type:

Promise <[Color]>

getNodesEffectiveFaceColor

IModel.getNodesEffectiveFaceColor(ids)
Arguments:
Return type:

Promise <[Color]>

getNodesEffectiveLineColor

IModel.getNodesEffectiveLineColor(ids)
Arguments:
Return type:

Promise <[Color]>

getNodesEffectiveOpacity

IModel.getNodesEffectiveOpacity(ids, elementType)
Arguments:
Return type:

Promise <[number]>

getNodesEffectivePointColor

IModel.getNodesEffectivePointColor(ids)
Arguments:
Return type:

Promise <[Color]>

getNodesEffectiveSpecularColor

IModel.getNodesEffectiveSpecularColor(ids)
Arguments:
Return type:

Promise <[Color]>

getNodesFaceColor

IModel.getNodesFaceColor(ids)
Arguments:
Return type:

Promise <[any]>

getNodesFaceEmissiveColor

IModel.getNodesFaceEmissiveColor(ids)
Arguments:
Return type:

Promise <[any]>

getNodesFaceSpecularColor

IModel.getNodesFaceSpecularColor(ids)
Arguments:
Return type:

Promise <[any]>

getNodesFromFiltersId

IModel.getNodesFromFiltersId(filtersId)
Arguments:
Return type:

FilteredNodes() | null

getNodesFromLayer

IModel.getNodesFromLayer(layerId[, onlyTreeNodes])
Arguments:
  • layerId (LayerId) – None
  • onlyTreeNodes (boolean()) – optional None
Return type:

[NodeId] | null

getNodesFromLayerName

IModel.getNodesFromLayerName(layerName[, onlyTreeNodes])
Arguments:
  • layerName (LayerName) – None
  • onlyTreeNodes (boolean()) – optional None
Return type:

[NodeId] | null

getNodesFromLayers

IModel.getNodesFromLayers(layersId[, onlyTreeNodes])
Arguments:
  • layersId ([LayerId]) – None
  • onlyTreeNodes (boolean()) – optional None
Return type:

[NodeId] | null

getNodesHaveTransparency

IModel.getNodesHaveTransparency(ids)
Arguments:
Return type:

Promise <[boolean]>

getNodesHighlighted

IModel.getNodesHighlighted(ids)
Arguments:
Return type:

Promise <[boolean]>

getNodesInstancingSamePart

IModel.getNodesInstancingSamePart(id)
Arguments:
Return type:

Promise <[NodeId] | null>

getNodesLineColor

IModel.getNodesLineColor(ids)
Arguments:
Return type:

Promise <[any]>

getNodesMaterial

IModel.getNodesMaterial(nodeIds)
Arguments:
Return type:

Promise <[IMaterial()]>

getNodesOpacity

IModel.getNodesOpacity(ids)
Arguments:
Return type:

Promise <[number]>

getNodesPointColor

IModel.getNodesPointColor(ids)
Arguments:
Return type:

Promise <[any]>

getOutOfHierarchy

IModel.getOutOfHierarchy(id)
Arguments:
Return type:

boolean

getPmiColor

IModel.getPmiColor()
Return type:Color

getPmiColorOverride

IModel.getPmiColorOverride()
Return type:boolean

getPmiSubtype

IModel.getPmiSubtype(pmiId)
Arguments:
Return type:

PmiSubType

getPmiTopologyReferences

IModel.getPmiTopologyReferences(pmiNodeId)
Arguments:
Return type:

[RefOnTopoItem()] | null

getPmiType

IModel.getPmiType(pmiId)
Arguments:
Return type:

PmiType

getPmis

IModel.getPmis()
Return type:IdStringMap()

getPointAttributes

IModel.getPointAttributes(id, pointIndex)
Arguments:
  • id (NodeId) – None
  • pointIndex (number()) – None
Return type:

Promise <SubentityAttributes() | null>

getRelationshipTypesFromBimId

IModel.getRelationshipTypesFromBimId(node, bimId)
Arguments:
Return type:

[RelationshipType]

getScInstanceKey

IModel.getScInstanceKey(nodeId)
Arguments:
Return type:

InstanceInc | null

getUniqueLayerNames

IModel.getUniqueLayerNames()
Return type:[LayerName]

getViewAxes

IModel.getViewAxes()
Return type:ViewAxes()

getVisibilityState

IModel.getVisibilityState(id)
Arguments:
Return type:

Promise <VisibilityState()>

hasDepthRange

IModel.hasDepthRange(nodeIds)
Arguments:
Return type:

Promise <[boolean]>

hasEffectiveGenericType

IModel.hasEffectiveGenericType(nodeId, genericType)
Arguments:
Return type:

boolean

isAnnotationView

IModel.isAnnotationView(cadViewNodeId)
Arguments:
Return type:

boolean

isCombineStateView

IModel.isCombineStateView(cadViewNodeId)
Arguments:
Return type:

boolean

isDrawing

IModel.isDrawing()
Return type:boolean

isFaceMeasurable

IModel.isFaceMeasurable(id, faceIndex)
Arguments:
  • id (NodeId) – None
  • faceIndex (number()) – None
Return type:

Promise <boolean>

isLineMeasurable

IModel.isLineMeasurable(id, lineIndex)
Arguments:
  • id (NodeId) – None
  • lineIndex (number()) – None
Return type:

Promise <boolean>

isMeasurable

IModel.isMeasurable()
Return type:boolean

isNodeLoaded

IModel.isNodeLoaded(id)
Arguments:
Return type:

boolean

isWithinExternalModel

IModel.isWithinExternalModel(id)
Arguments:
Return type:

boolean

loadMeasurementFromFile

IModel.loadMeasurementFromFile(filename)
Arguments:
  • filename (string()) – None
Return type:

Promise <void>

loadMeasurementFromJson

IModel.loadMeasurementFromJson(json)
Arguments:
  • json (any()) – None
Return type:

Promise <void>

loadMeasurementFromString

IModel.loadMeasurementFromString(str)
Arguments:
  • str (string()) – None
Return type:

Promise <void>

loadSubtreeFromModel

IModel.loadSubtreeFromModel(nodeId, modelName, args)
Arguments:
  • nodeId (NodeId) – None
  • modelName (ScModelName()) – None
  • args ([any]()) – None
Return type:

Promise <[NodeId]>

loadSubtreeFromScsBuffer

IModel.loadSubtreeFromScsBuffer(nodeId, buffer, args)
Arguments:
  • nodeId (NodeId) – None
  • buffer (ScsBuffer()) – None
  • args ([any]()) – None
Return type:

Promise <[NodeId]>

loadSubtreeFromScsFile

IModel.loadSubtreeFromScsFile(nodeId, scsFilename, args)
Arguments:
  • nodeId (NodeId) – None
  • scsFilename (ScsUri) – None
  • args ([any]()) – None
Return type:

Promise <[NodeId]>

loadSubtreeFromScsXmlBuffer

IModel.loadSubtreeFromScsXmlBuffer(nodeId, xmlData[, modelNameToScs, args])
Arguments:
  • nodeId (NodeId) – None
  • xmlData (string | Document()) – None
  • modelNameToScs (ModelNameToScsFileFunc | null) – optional None
  • args ([any]()) – None
Return type:

Promise <[NodeId]>

loadSubtreeFromScsXmlFile

IModel.loadSubtreeFromScsXmlFile(nodeId, xmlFilename[, modelNameToScs, args])
Arguments:
Return type:

Promise <[NodeId]>

loadSubtreeFromXmlBuffer

IModel.loadSubtreeFromXmlBuffer(nodeId, xmlData[, massageModelName, args])
Arguments:
  • nodeId (NodeId) – None
  • xmlData (string | Document()) – None
  • massageModelName (MassageModelNameFunc | null) – optional None
  • args ([any]()) – None
Return type:

Promise <[NodeId]>

loadSubtreeFromXmlFile

IModel.loadSubtreeFromXmlFile(nodeId, xmlFilename[, massageModelName, args])
Arguments:
Return type:

Promise <[NodeId]>

registerBimNodes

IModel.registerBimNodes(id, attributeToMask[, legacy_useAttributeTitle])
Arguments:
  • id (NodeId) – None
  • attributeToMask (function()) – None
  • legacy_useAttributeTitle (string | boolean | null()) – optional None
Return type:

Promise <void>

IModel.attributeToMask(value)
Arguments:
  • value (string()) – None
Return type:

BimMask

registerIfcNodes

IModel.registerIfcNodes(id[, legacy_useAttributeTitle])
Arguments:
  • id (NodeId) – None
  • legacy_useAttributeTitle (string | boolean | null()) – optional None
Return type:

Promise <void>

replaceMesh

IModel.replaceMesh(id, data)
Arguments:
Return type:

Promise <void>

requestNodes

IModel.requestNodes(nodeIds)
Arguments:
Return type:

Promise <void>

reset

IModel.reset()
Return type:Promise <void>

resetModelHighlight

IModel.resetModelHighlight()
Return type:Promise <void>

resetModelOpacity

IModel.resetModelOpacity()
Return type:void

resetNodeMatrixToInitial

IModel.resetNodeMatrixToInitial(id)
Arguments:
Return type:

void

resetNodesColor

IModel.resetNodesColor()
Return type:Promise <void>

resetNodesMaterial

IModel.resetNodesMaterial(nodeIds[, params])
Arguments:
Return type:

void

resetNodesOpacity

IModel.resetNodesOpacity(ids)
Arguments:
Return type:

void

resetNodesTransform

IModel.resetNodesTransform()
Return type:Promise <void>

resetNodesVisibility

IModel.resetNodesVisibility()
Return type:Promise <void>

setBehaviorInitiallyHidden

IModel.setBehaviorInitiallyHidden(enabled)
Arguments:
  • enabled (boolean()) – None
Return type:

void

setBodyNodesVisibility

IModel.setBodyNodesVisibility(id, visibilityFormatter)
Arguments:
  • id (NodeId) – None
  • visibilityFormatter (boolean | function()) – None
Return type:

Promise <void>

IModel.visibilityFormatter(node)
Arguments:
Return type:

boolean | undefined

setDepthRange

IModel.setDepthRange(nodeIds, min, max)
Arguments:
  • nodeIds ([NodeId]) – None
  • min (number()) – None
  • max (number()) – None
Return type:

Promise <void>

setEdgeProperty

IModel.setEdgeProperty(id, edgeId, prop)
Arguments:
  • id (NodeId) – None
  • edgeId (number()) – None
  • prop (Base) – None
Return type:

void

setEnableAutomaticUnitScaling

IModel.setEnableAutomaticUnitScaling(enabled)
Arguments:
  • enabled (boolean()) – None
Return type:

void

setFaceProperty

IModel.setFaceProperty(id, faceId, prop)
Arguments:
  • id (NodeId) – None
  • faceId (number()) – None
  • prop (Base) – None
Return type:

void

setInstanceModifier

IModel.setInstanceModifier(instanceModifier, nodeIds, value)
Arguments:
Return type:

Promise <void>

setMeshLevel

IModel.setMeshLevel(nodeIds, meshLevel)
Arguments:
  • nodeIds ([NodeId]) – None
  • meshLevel (number()) – None
Return type:

Promise <void>

setMetallicRoughness

IModel.setMetallicRoughness(nodeIds, metallicFactor, roughnessFactor)
Arguments:
  • nodeIds ([NodeId]) – None
  • metallicFactor (number()) – None
  • roughnessFactor (number()) – None
Return type:

void

setNodeFaceColor

IModel.setNodeFaceColor(id, faceId, color)
Arguments:
  • id (NodeId) – None
  • faceId (number()) – None
  • color (Color) – None
Return type:

void

setNodeFaceHighlighted

IModel.setNodeFaceHighlighted(id, faceId, highlighted)
Arguments:
  • id (NodeId) – None
  • faceId (number()) – None
  • highlighted (boolean()) – None
Return type:

void

setNodeFaceVisibility

IModel.setNodeFaceVisibility(id, faceId, visibility)
Arguments:
  • id (NodeId) – None
  • faceId (number()) – None
  • visibility (boolean()) – None
Return type:

void

setNodeLineColor

IModel.setNodeLineColor(id, lineId, color)
Arguments:
  • id (NodeId) – None
  • lineId (number()) – None
  • color (Color) – None
Return type:

void

setNodeLineHighlighted

IModel.setNodeLineHighlighted(id, lineId, highlighted)
Arguments:
  • id (NodeId) – None
  • lineId (number()) – None
  • highlighted (boolean()) – None
Return type:

void

setNodeLineVisibility

IModel.setNodeLineVisibility(id, lineId, visibility)
Arguments:
  • id (NodeId) – None
  • lineId (number()) – None
  • visibility (boolean()) – None
Return type:

void

setNodeMatrix

IModel.setNodeMatrix(id, matrix[, initial])
Arguments:
  • id (NodeId) – None
  • matrix (Matrix()) – None
  • initial (boolean()) – optional None
Return type:

Promise <void>

setNodePointColor

IModel.setNodePointColor(id, pointId, color)
Arguments:
  • id (NodeId) – None
  • pointId (number()) – None
  • color (Color) – None
Return type:

void

setNodePointHighlighted

IModel.setNodePointHighlighted(id, pointId, highlighted)
Arguments:
  • id (NodeId) – None
  • pointId (number()) – None
  • highlighted (boolean()) – None
Return type:

void

setNodePointVisibility

IModel.setNodePointVisibility(id, pointId, visibility)
Arguments:
  • id (NodeId) – None
  • pointId (number()) – None
  • visibility (boolean()) – None
Return type:

void

setNodesAmbientColor

IModel.setNodesAmbientColor(ids, color)
Arguments:
Return type:

void

setNodesAmbientMix

IModel.setNodesAmbientMix(ids, value)
Arguments:
  • ids ([NodeId]) – None
  • value (number()) – None
Return type:

void

setNodesColors

IModel.setNodesColors(colorMap[, alsoApplyToWireframe[, alsoApplyToPoints]])
Arguments:
  • colorMap (Map <NodeId, Color> | IdColorMap()) – None
  • alsoApplyToWireframe (boolean()) – optional None
  • alsoApplyToPoints (boolean()) – optional None
Return type:

Promise <void>

setNodesCullingVector

IModel.setNodesCullingVector(nodeIds, space, vector, toleranceDegrees)
Arguments:
Return type:

Promise <void>

setNodesFaceColor

IModel.setNodesFaceColor(ids, color)
Arguments:
Return type:

void

setNodesFaceEmissiveColor

IModel.setNodesFaceEmissiveColor(ids, color)
Arguments:
Return type:

void

setNodesFaceSpecularColor

IModel.setNodesFaceSpecularColor(ids, color)
Arguments:
Return type:

void

setNodesFaceSpecularIntensity

IModel.setNodesFaceSpecularIntensity(ids, value)
Arguments:
  • ids ([NodeId]) – None
  • value (number()) – None
Return type:

void

setNodesHighlighted

IModel.setNodesHighlighted(ids, highlighted)
Arguments:
  • ids ([NodeId]) – None
  • highlighted (boolean()) – None
Return type:

void

setNodesLineColor

IModel.setNodesLineColor(ids, color)
Arguments:
Return type:

void

setNodesLinePattern

IModel.setNodesLinePattern(nodeIds, pattern, patternLength, patternLengthUnit)
Arguments:
Return type:

void

setNodesMaterial

IModel.setNodesMaterial(nodeIds, material)
Arguments:
Return type:

void

setNodesOpacities

IModel.setNodesOpacities(params)
Arguments:
Return type:

void

setNodesOpacity

IModel.setNodesOpacity(ids, opacity)
Arguments:
  • ids ([NodeId]) – None
  • opacity (number()) – None
Return type:

void

setNodesPointColor

IModel.setNodesPointColor(ids, color)
Arguments:
Return type:

void

setNodesTexture

IModel.setNodesTexture(nodeIds, options)
Arguments:
Return type:

Promise <void>

setNodesVisibilities

IModel.setNodesVisibilities(mapping[, initiallyHiddenStayHidden])
Arguments:
  • mapping (Map <NodeId, boolean> | IdBooleanMap()) – None
  • initiallyHiddenStayHidden (boolean | null()) – optional None
Return type:

Promise <void>

setNodesVisibility

IModel.setNodesVisibility(ids, value[, initiallyHiddenStayHidden])
Arguments:
  • ids ([NodeId]) – None
  • value (boolean()) – None
  • initiallyHiddenStayHidden (boolean | null()) – optional None
Return type:

void

setPart

IModel.setPart(assemblyNodeId, partNodeId)
Arguments:
  • assemblyNodeId (NodeId | undefined | null) – None
  • partNodeId (PartId | undefined | null) – None
Return type:

boolean

setPhysicalProperties

IModel.setPhysicalProperties(id, gravityCenter, surfaceArea, volume)
Arguments:
  • id (NodeId) – None
  • gravityCenter (Point3()) – None
  • surfaceArea (number()) – None
  • volume (number()) – None
Return type:

boolean

setPmiColor

IModel.setPmiColor(color)
Arguments:
Return type:

void

setPmiColorOverride

IModel.setPmiColorOverride(enableOverride[, rootId])
Arguments:
  • enableOverride (boolean()) – None
  • rootId (NodeId) – optional None
Return type:

Promise <void>

setViewAxes

IModel.setViewAxes(frontVector, upVector)
Arguments:
Return type:

void

switchToModel

IModel.switchToModel(newModelFilename)
Arguments:
  • newModelFilename (ScModelName()) – None
Return type:

Promise <[NodeId]>

triangulatePolygon

IModel.triangulatePolygon(polygonPoints, normal)
Arguments:
  • polygonPoints (Float32Array | [number]()) – None
  • normal (Point3()) – None
Return type:

Float32Array

unsetDepthRange

IModel.unsetDepthRange(nodeIds)
Arguments:
Return type:

void

unsetMetallicRoughness

IModel.unsetMetallicRoughness(nodeIds)
Arguments:
Return type:

void

unsetNodeFaceColor

IModel.unsetNodeFaceColor(id, faceId)
Arguments:
  • id (NodeId) – None
  • faceId (number()) – None
Return type:

void

unsetNodeLineColor

IModel.unsetNodeLineColor(id, lineId)
Arguments:
  • id (NodeId) – None
  • lineId (number()) – None
Return type:

void

unsetNodePointColor

IModel.unsetNodePointColor(id, pointId)
Arguments:
  • id (NodeId) – None
  • pointId (number()) – None
Return type:

void

unsetNodesAmbientColor

IModel.unsetNodesAmbientColor(ids)
Arguments:
Return type:

void

unsetNodesCullingVectors

IModel.unsetNodesCullingVectors(nodeIds)
Arguments:
Return type:

Promise <void>

unsetNodesFaceColor

IModel.unsetNodesFaceColor(ids)
Arguments:
Return type:

void

unsetNodesFaceEmissiveColor

IModel.unsetNodesFaceEmissiveColor(ids)
Arguments:
Return type:

void

unsetNodesFaceSpecularColor

IModel.unsetNodesFaceSpecularColor(ids)
Arguments:
Return type:

void

unsetNodesFaceSpecularIntensity

IModel.unsetNodesFaceSpecularIntensity(ids)
Arguments:
Return type:

void

unsetNodesLineColor

IModel.unsetNodesLineColor(ids)
Arguments:
Return type:

void

unsetNodesLinePattern

IModel.unsetNodesLinePattern(nodeIds)
Arguments:
Return type:

void

unsetNodesPointColor

IModel.unsetNodesPointColor(ids)
Arguments:
Return type:

void

unsetNodesTexture

IModel.unsetNodesTexture(nodeIds)
Arguments:
Return type:

void

viewAxesHaveBeenSet

IModel.viewAxesHaveBeenSet()
Return type:boolean