/// <summary> /// Calculates number of risers for a stair. /// </summary> /// <param name="exporterIFC"> /// The ExporterIFC object. /// </param> /// <param name="extrusionCreationData"> /// The IFCExtrusionCreationData. /// </param> /// <param name="element"> /// The element to calculate the value. /// </param> /// <param name="elementType"> /// The element type. /// </param> /// <returns> /// True if the operation succeed, false otherwise. /// </returns> public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType) { bool valid = true; if (m_CurrentElement != element) { m_CurrentElement = element; if (StairsExporter.IsLegacyStairs(element)) { ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element, out m_NumberOfRisers, out m_NumberOfTreads, out m_RiserHeight, out m_TreadLength, out m_TreadLengthAtInnerSide, out m_NosingLength, out m_WaistThickness); m_TreadLengthAtOffset = m_TreadLength; m_WalkingLineOffset = m_WaistThickness / 2.0; } else if (element is Stairs) { Stairs stairs = element as Stairs; m_NumberOfRisers = stairs.ActualRisersNumber; m_NumberOfTreads = stairs.ActualTreadsNumber; m_RiserHeight = UnitUtil.ScaleLength(stairs.ActualRiserHeight); m_TreadLength = UnitUtil.ScaleLength(stairs.ActualTreadDepth); } else if (element is StairsRun) { StairsRun stairsRun = element as StairsRun; StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType; Stairs stairs = stairsRun.GetStairs(); StairsType stairsType = stairs.Document.GetElement(stairs.GetTypeId()) as StairsType; m_NumberOfRisers = stairs.ActualRisersNumber; m_NumberOfTreads = stairs.ActualTreadsNumber; m_RiserHeight = UnitUtil.ScaleLength(stairs.ActualRiserHeight); m_TreadLength = UnitUtil.ScaleLength(stairs.ActualTreadDepth); m_TreadLengthAtOffset = m_TreadLength; m_NosingLength = UnitUtil.ScaleLength(stairsRunType.NosingLength); m_WaistThickness = UnitUtil.ScaleLength(stairsRun.ActualRunWidth); m_WalkingLineOffset = m_WaistThickness / 2.0; double treadLengthAtInnerSide; if (ParameterUtil.GetDoubleValueFromElement(stairsType, BuiltInParameter.STAIRSTYPE_MINIMUM_TREAD_WIDTH_INSIDE_BOUNDARY, out treadLengthAtInnerSide) != null) { m_TreadLengthAtInnerSide = UnitUtil.ScaleLength(treadLengthAtInnerSide); } else { m_TreadLengthAtInnerSide = 0.0; } } else { valid = false; } } return(valid); }
/// <summary> /// Calculates number of risers for a stair. /// </summary> /// <param name="exporterIFC"> /// The ExporterIFC object. /// </param> /// <param name="extrusionCreationData"> /// The IFCExtrusionCreationData. /// </param> /// <param name="element"> /// The element to calculate the value. /// </param> /// <param name="elementType"> /// The element type. /// </param> /// <returns> /// True if the operation succeed, false otherwise. /// </returns> public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap) { bool valid = true; if (StairsExporter.IsLegacyStairs(element)) { double riserHeight, treadLength, nosingLength, waistThickness = 0; int numberOfRisers, numberOfTreads = 0; ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element, out numberOfRisers, out numberOfTreads, out riserHeight, out treadLength, out m_TreadLengthAtInnerSide, out nosingLength, out waistThickness); } else if (element is Stairs || element is StairsRun) { Stairs stairs; if (element is StairsRun) { StairsRun stairsRun = element as StairsRun; stairs = stairsRun.GetStairs(); } else { stairs = element as Stairs; } StairsType stairsType = stairs.Document.GetElement(stairs.GetTypeId()) as StairsType; double treadLengthAtInnerSide; if (ParameterUtil.GetDoubleValueFromElement(stairsType, BuiltInParameter.STAIRSTYPE_MINIMUM_TREAD_WIDTH_INSIDE_BOUNDARY, out treadLengthAtInnerSide) != null) { m_TreadLengthAtInnerSide = UnitUtil.ScaleLength(treadLengthAtInnerSide); } if (m_TreadLengthAtInnerSide <= 0) { m_TreadLengthAtInnerSide = UnitUtil.ScaleLength(stairs.ActualTreadDepth); } } else { valid = false; } // Get override from parameter double treadLengthAtInnerSideOverride = 0.0; if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out treadLengthAtInnerSideOverride) != null || ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out treadLengthAtInnerSideOverride) != null) { m_TreadLengthAtInnerSide = UnitUtil.ScaleArea(treadLengthAtInnerSideOverride); } return(valid); }
/// <summary> /// Calculates number of risers for a stair. /// </summary> /// <param name="exporterIFC"> /// The ExporterIFC object. /// </param> /// <param name="extrusionCreationData"> /// The IFCExtrusionCreationData. /// </param> /// <param name="element"> /// The element to calculate the value. /// </param> /// <param name="elementType"> /// The element type. /// </param> /// <returns> /// True if the operation succeed, false otherwise. /// </returns> public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType) { bool valid = true; if (m_CurrentElement != element) { double scale = exporterIFC.LinearScale; m_CurrentElement = element; if (StairsExporter.IsLegacyStairs(element)) { ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element, out m_NumberOfRisers, out m_NumberOfTreads, out m_RiserHeight, out m_TreadLength, out m_TreadLengthAtInnerSide, out m_NosingLength, out m_WaistThickness); m_TreadLengthAtOffset = m_TreadLength; m_WalkingLineOffset = m_WaistThickness / 2.0; } else if (element is Stairs) { Stairs stairs = element as Stairs; m_NumberOfRisers = stairs.ActualRisersNumber; m_NumberOfTreads = stairs.ActualTreadsNumber; m_RiserHeight = stairs.ActualRiserHeight * scale; m_TreadLength = stairs.ActualTreadDepth * scale; } else if (element is StairsRun) { StairsRun stairsRun = element as StairsRun; StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType; Stairs stairs = stairsRun.GetStairs(); StairsType stairsType = stairs.Document.GetElement(stairs.GetTypeId()) as StairsType; m_NumberOfRisers = stairs.ActualRisersNumber; m_NumberOfTreads = stairs.ActualTreadsNumber; m_RiserHeight = stairs.ActualRiserHeight * scale; m_TreadLength = stairs.ActualTreadDepth * scale; m_TreadLengthAtOffset = m_TreadLength; m_NosingLength = stairsRunType.NosingLength * scale; m_WaistThickness = stairsRun.ActualRunWidth * scale; m_WalkingLineOffset = m_WaistThickness / 2.0; Parameter treadLengthAtInnerSideParam = stairsType.get_Parameter(BuiltInParameter.STAIRSTYPE_MINIMUM_TREAD_WIDTH_INSIDE_BOUNDARY); m_TreadLengthAtInnerSide = (treadLengthAtInnerSideParam != null) ? (treadLengthAtInnerSideParam.AsDouble() * scale) : 0.0; } else { valid = false; } } return(valid); }
/// <summary> /// Calculates number of risers for a stair. /// </summary> /// <param name="exporterIFC"> /// The ExporterIFC object. /// </param> /// <param name="extrusionCreationData"> /// The IFCExtrusionCreationData. /// </param> /// <param name="element"> /// The element to calculate the value. /// </param> /// <param name="elementType"> /// The element type. /// </param> /// <returns> /// True if the operation succeed, false otherwise. /// </returns> public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap) { bool valid = true; if (StairsExporter.IsLegacyStairs(element)) { double riserHeight, treadLength, treadLengthAtInnerSide, nosingLength, waistThickness = 0; int numberOfRisers, numberOfTreads = 0; ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element, out numberOfRisers, out numberOfTreads, out riserHeight, out treadLength, out treadLengthAtInnerSide, out nosingLength, out waistThickness); m_WalkingLineOffset = waistThickness / 2.0; // !! The waist thickness seems to be wrongly associated with the width of the run! } else if (element is Stairs) { Stairs stairs = element as Stairs; ICollection <ElementId> stairRuns = stairs.GetStairsRuns(); if (stairRuns.Count > 0) { // Get the run width from one of the run/flight to compute the walking line offset StairsRun run = stairs.Document.GetElement(stairRuns.First()) as StairsRun; m_WalkingLineOffset = run.ActualRunWidth / 2.0; } } else if (element is StairsRun) { StairsRun stairsRun = element as StairsRun; StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType; m_WalkingLineOffset = stairsRun.ActualRunWidth / 2.0; } else { valid = false; } // Get override from parameter double walkingLineOffsetOverride = 0.0; if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out walkingLineOffsetOverride) != null || ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out walkingLineOffsetOverride) != null) { m_WalkingLineOffset = UnitUtil.ScaleArea(walkingLineOffsetOverride); } return(valid); }
/// <summary> /// Calculates number of risers for a stair. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param> /// <param name="element">The element to calculate the value.</param> /// <param name="elementType">The element type.</param> /// <returns>True if the operation succeed, false otherwise.</returns> public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap) { bool valid = true; if (StairsExporter.IsLegacyStairs(element)) { double riserHeight, treadLength, treadLengthAtInnerSide, nosingLength, waistThickness = 0; int numberOfTreads; ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element, out m_NumberOfRisers, out numberOfTreads, out riserHeight, out treadLength, out treadLengthAtInnerSide, out nosingLength, out waistThickness); } else if (element is Stairs) { Stairs stairs = element as Stairs; m_NumberOfRisers = stairs.ActualRisersNumber; } else if (element is StairsRun) { StairsRun stairsRun = element as StairsRun; StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType; m_NumberOfRisers = stairsRun.ActualRisersNumber; } else { valid = false; } // Get override from parameter int?noRiserOverride = ParameterUtil.GetIntValueFromElementOrSymbol(element, entryMap.RevitParameterName); if (!noRiserOverride.HasValue) { noRiserOverride = ParameterUtil.GetIntValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName); } if (noRiserOverride.HasValue) { m_NumberOfRisers = noRiserOverride.Value; valid = true; } return(valid); }
/// <summary> /// Calculates number of risers for a stair. /// </summary> /// <param name="exporterIFC"> /// The ExporterIFC object. /// </param> /// <param name="extrusionCreationData"> /// The IFCExtrusionCreationData. /// </param> /// <param name="element"> /// The element to calculate the value. /// </param> /// <param name="elementType"> /// The element type. /// </param> /// <returns> /// True if the operation succeed, false otherwise. /// </returns> public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap) { bool valid = true; if (StairsExporter.IsLegacyStairs(element)) { double riserHeight, treadLength, treadLengthAtInnerSide, nosingLength, waistThickness = 0; int numberOfRisers, numberOfTreads = 0; ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element, out numberOfRisers, out numberOfTreads, out riserHeight, out treadLength, out treadLengthAtInnerSide, out nosingLength, out waistThickness); m_TreadLengthAtOffset = treadLength; } else if (element is Stairs) { Stairs stairs = element as Stairs; m_TreadLengthAtOffset = UnitUtil.ScaleLength(stairs.ActualTreadDepth); } else if (element is StairsRun) { StairsRun stairsRun = element as StairsRun; Stairs stairs = stairsRun.GetStairs(); m_TreadLengthAtOffset = UnitUtil.ScaleLength(stairs.ActualTreadDepth); } else { valid = false; } // Get override from parameter double treadLengthAtOffset = 0.0; if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out treadLengthAtOffset) != null || ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out treadLengthAtOffset) != null) { m_TreadLengthAtOffset = UnitUtil.ScaleArea(treadLengthAtOffset); } return(valid); }
/// <summary> /// Exports a ramp to IfcRamp. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="element">The ramp element.</param> /// <param name="geometryElement">The geometry element.</param> /// <param name="productWrapper">The ProductWrapper.</param> public static void Export(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, ProductWrapper productWrapper) { string ifcEnumType = ExporterUtil.GetIFCTypeFromExportTable(exporterIFC, element); IFCFile file = exporterIFC.GetFile(); using (IFCTransaction tr = new IFCTransaction(file)) { StairsExporter.ExportLegacyStairOrRampAsContainer(exporterIFC, ifcEnumType, element, geometryElement, productWrapper); // If we didn't create a handle here, then the element wasn't a "native" Ramp, and is likely a FamilyInstance or a DirectShape. if (IFCAnyHandleUtil.IsNullOrHasNoValue(productWrapper.GetAnElement())) { int numFlights = GetNumFlightsForRamp(exporterIFC, element); if (numFlights > 0) { ExportRamp(exporterIFC, ifcEnumType, element, geometryElement, numFlights, productWrapper); } } tr.Commit(); } }
/// <summary> /// Calculates number of risers for a stair. /// </summary> /// <param name="exporterIFC"> /// The ExporterIFC object. /// </param> /// <param name="extrusionCreationData"> /// The IFCExtrusionCreationData. /// </param> /// <param name="element"> /// The element to calculate the value. /// </param> /// <param name="elementType"> /// The element type. /// </param> /// <returns> /// True if the operation succeed, false otherwise. /// </returns> public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType) { bool valid = true; if (StairsExporter.IsLegacyStairs(element)) { double riserHeight, treadLengthAtInnerSide, nosingLength, waistThickness = 0; int numberOfRisers, numberOfTreads = 0; ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element, out numberOfRisers, out numberOfTreads, out riserHeight, out m_TreadLength, out treadLengthAtInnerSide, out nosingLength, out waistThickness); } else if (element is Stairs) { Stairs stairs = element as Stairs; m_TreadLength = UnitUtil.ScaleLength(stairs.ActualTreadDepth); } else if (element is StairsRun) { StairsRun stairsRun = element as StairsRun; StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType; Stairs stairs = stairsRun.GetStairs(); m_TreadLength = UnitUtil.ScaleLength(stairs.ActualTreadDepth); } else { valid = false; } // Get override from parameter if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "TreadLength", out m_TreadLength) != null) { m_TreadLength = UnitUtil.ScaleArea(m_TreadLength); } return(valid); }
/// <summary> /// Calculates number of risers for a stair. /// </summary> /// <param name="exporterIFC"> /// The ExporterIFC object. /// </param> /// <param name="extrusionCreationData"> /// The IFCExtrusionCreationData. /// </param> /// <param name="element"> /// The element to calculate the value. /// </param> /// <param name="elementType"> /// The element type. /// </param> /// <returns> /// True if the operation succeed, false otherwise. /// </returns> public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap) { bool valid = true; if (StairsExporter.IsLegacyStairs(element)) { double riserHeight, treadLength, treadLengthAtInnerSide, waistThickness = 0; int numberOfRisers, numberOfTreads = 0; ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element, out numberOfRisers, out numberOfTreads, out riserHeight, out treadLength, out treadLengthAtInnerSide, out m_NosingLength, out waistThickness); } else if (element is Stairs) { Stairs stairs = element as Stairs; ICollection <ElementId> stairRuns = stairs.GetStairsRuns(); if (stairRuns.Count > 0) { // Get the run width from one of the run/flight to compute the walking line offset StairsRun run = stairs.Document.GetElement(stairRuns.First()) as StairsRun; StairsRunType stairsRunType = run.Document.GetElement(run.GetTypeId()) as StairsRunType; m_NosingLength = UnitUtil.ScaleLength(stairsRunType.NosingLength); } } else if (element is StairsRun) { StairsRun stairsRun = element as StairsRun; StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType; m_NosingLength = UnitUtil.ScaleLength(stairsRunType.NosingLength); } else { valid = false; } return(valid); }
private static ElementId GetStairOrRampHostId(ExporterIFC exporterIFC, Railing railingElem) { ElementId returnHostId = ElementId.InvalidElementId; if (railingElem == null) { return(returnHostId); } ElementId hostId = railingElem.HostId; if (hostId == ElementId.InvalidElementId) { return(returnHostId); } if (!ExporterCacheManager.StairRampContainerInfoCache.ContainsStairRampContainerInfo(hostId)) { return(returnHostId); } Element host = railingElem.Document.GetElement(hostId); if (host == null) { return(returnHostId); } if (!(host is Stairs) && !StairsExporter.IsLegacyStairs(host) && !RampExporter.IsRamp(host)) { return(returnHostId); } returnHostId = hostId; return(returnHostId); }
/// <summary> /// Gets the number of flights of a multi-story ramp. /// </summary> /// <param name="exporterIFC"> /// The exporter. /// </param> /// <param name="element"> /// The element. /// </param> /// <returns> /// The number of flights (at least 1.) /// </returns> static public int GetNumFlightsForRamp(ExporterIFC exporterIFC, Element element) { return(StairsExporter.GetNumFlightsForLegacyStair(exporterIFC, element, GetDefaultHeightForRamp())); }
/// <summary> /// Gets the ramp height for a ramp. /// </summary> /// <param name="exporterIFC"> /// The exporter. /// </param> /// <param name="element"> /// The element. /// </param> /// <returns> /// The unscaled height. /// </returns> static public double GetRampHeight(ExporterIFC exporterIFC, Element element) { // Re-use the code for stairs height for legacy stairs. return(StairsExporter.GetStairsHeightForLegacyStair(exporterIFC, element, GetDefaultHeightForRamp())); }
/// <summary> /// Returns the base level of an element. The method used to find the base level depends on the element type. /// </summary> public static ElementId GetBaseLevelIdForElement(Element elem) { // If the element is view specific, use the level of the parent view. if (elem.ViewSpecific) { ElementId viewId = elem.OwnerViewId; ElementId viewSpecificlevelId; if (ExporterCacheManager.DBViewsToExport.TryGetValue(viewId, out viewSpecificlevelId)) { return(viewSpecificlevelId); } } // Some elements will have a parameter that defines the base level. Find it if possible. IList <BuiltInParameter> priortizedParameterList = new List <BuiltInParameter>(); Element elemToCheck = elem; if (elem is Wall) { priortizedParameterList.Add(BuiltInParameter.WALL_BASE_CONSTRAINT); } else if (elem is FamilyInstance) { // If this is a nested family, check the top-level instance for the level parameter information. elemToCheck = (elem as FamilyInstance).SuperComponent; if (elemToCheck == null) { elemToCheck = elem; } // Inplace wall parameter. priortizedParameterList.Add(BuiltInParameter.FAMILY_BASE_LEVEL_PARAM); // There are two Family-related parameters for non-inplace walls: INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM and INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM. // We prioritize INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM over INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM. priortizedParameterList.Add(BuiltInParameter.INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM); priortizedParameterList.Add(BuiltInParameter.INSTANCE_REFERENCE_LEVEL_PARAM); } else if (elem is Truss) { priortizedParameterList.Add(BuiltInParameter.TRUSS_ELEMENT_REFERENCE_LEVEL_PARAM); } else if (elem is Stairs || StairsExporter.IsLegacyStairs(elem)) { priortizedParameterList.Add(BuiltInParameter.STAIRS_BASE_LEVEL_PARAM); } else if (elem is ExtrusionRoof) { priortizedParameterList.Add(BuiltInParameter.ROOF_CONSTRAINT_LEVEL_PARAM); } // If the level parameter was found, use it. Otherwise, try asking the element directly. foreach (BuiltInParameter levelParameterVal in priortizedParameterList) { Parameter levelParameter = elemToCheck.get_Parameter(levelParameterVal); if (levelParameter != null && levelParameter.StorageType == StorageType.ElementId) { ElementId levelId = levelParameter.AsElementId(); if (levelId != ElementId.InvalidElementId) { return(levelId); } } } // Didn't find a parameter; try asking the element directly. if (elem is MEPCurve) { Level level = (elem as MEPCurve).ReferenceLevel; if (level != null) { return(level.Id); } } return(elem.LevelId); }
/// <summary> /// Exports an element as an IFC assembly. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="element">The element.</param> /// <param name="productWrapper">The ProductWrapper.</param> /// <returns>True if exported successfully, false otherwise.</returns> public static bool ExportAssemblyInstanceElement(ExporterIFC exporterIFC, AssemblyInstance element, ProductWrapper productWrapper) { if (element == null) { return(false); } IFCFile file = exporterIFC.GetFile(); using (IFCTransaction tr = new IFCTransaction(file)) { IFCAnyHandle assemblyInstanceHnd = null; string guid = GUIDUtil.CreateGUID(element); IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle; IFCAnyHandle localPlacement = null; PlacementSetter placementSetter = null; IFCLevelInfo levelInfo = null; bool relateToLevel = true; string ifcEnumType; IFCExportInfoPair exportAs = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType); if (exportAs.ExportInstance == IFCEntityType.IfcSystem) { string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element)); string description = NamingUtil.GetDescriptionOverride(element, null); string objectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.GetFamilyAndTypeName(element)); assemblyInstanceHnd = IFCInstanceExporter.CreateSystem(file, guid, ownerHistory, name, description, objectType); // Create classification reference when System has classification filed name assigned to it ClassificationUtil.CreateClassification(exporterIFC, file, element, assemblyInstanceHnd); HashSet <IFCAnyHandle> relatedBuildings = new HashSet <IFCAnyHandle>(); relatedBuildings.Add(ExporterCacheManager.BuildingHandle); IFCAnyHandle relServicesBuildings = IFCInstanceExporter.CreateRelServicesBuildings(file, GUIDUtil.CreateGUID(), ExporterCacheManager.OwnerHistoryHandle, null, null, assemblyInstanceHnd, relatedBuildings); relateToLevel = false; // Already related to the building via IfcRelServicesBuildings. } else { // Check for containment override IFCAnyHandle overrideContainerHnd = null; ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd); using (placementSetter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd)) { IFCAnyHandle representation = null; // We have limited support for exporting assemblies as other container types. localPlacement = placementSetter.LocalPlacement; levelInfo = placementSetter.LevelInfo; switch (exportAs.ExportInstance) { case IFCEntityType.IfcCurtainWall: //case IFCExportType.IfcCurtainWallType: //string cwPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, ifcEnumType, "IfcCurtainWallType"); assemblyInstanceHnd = IFCInstanceExporter.CreateCurtainWall(exporterIFC, element, guid, ownerHistory, localPlacement, representation, ifcEnumType); break; case IFCEntityType.IfcRamp: string rampPredefinedType = RampExporter.GetIFCRampType(ifcEnumType); //rampPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, rampPredefinedType, "IfcRampType"); assemblyInstanceHnd = IFCInstanceExporter.CreateRamp(exporterIFC, element, guid, ownerHistory, localPlacement, representation, rampPredefinedType); break; case IFCEntityType.IfcRoof: //string roofPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, ifcEnumType, "IfcRoofType"); assemblyInstanceHnd = IFCInstanceExporter.CreateRoof(exporterIFC, element, guid, ownerHistory, localPlacement, representation, ifcEnumType); break; case IFCEntityType.IfcStair: string stairPredefinedType = StairsExporter.GetIFCStairType(ifcEnumType); //stairPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, stairPredefinedType, "IfcStairType"); assemblyInstanceHnd = IFCInstanceExporter.CreateStair(exporterIFC, element, guid, ownerHistory, localPlacement, representation, stairPredefinedType); break; case IFCEntityType.IfcWall: //string wallPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, ifcEnumType, "IfcWallType"); assemblyInstanceHnd = IFCInstanceExporter.CreateWall(exporterIFC, element, guid, ownerHistory, localPlacement, representation, ifcEnumType); break; default: string objectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.GetFamilyAndTypeName(element)); IFCElementAssemblyType assemblyPredefinedType = GetPredefinedTypeFromObjectType(objectType); assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(exporterIFC, element, guid, ownerHistory, localPlacement, representation, IFCAssemblyPlace.NotDefined, assemblyPredefinedType); break; } } } if (assemblyInstanceHnd == null) { return(false); } // relateToLevel depends on how the AssemblyInstance is being mapped to IFC, above. productWrapper.AddElement(element, assemblyInstanceHnd, levelInfo, null, relateToLevel, exportAs); ExporterCacheManager.AssemblyInstanceCache.RegisterAssemblyInstance(element.Id, assemblyInstanceHnd); tr.Commit(); return(true); } }
/// <summary> /// Exports an element as an IFC assembly. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="element">The element.</param> /// <param name="productWrapper">The ProductWrapper.</param> /// <returns>True if exported successfully, false otherwise.</returns> public static bool ExportAssemblyInstanceElement(ExporterIFC exporterIFC, AssemblyInstance element, ProductWrapper productWrapper) { if (element == null) { return(false); } IFCFile file = exporterIFC.GetFile(); using (IFCTransaction tr = new IFCTransaction(file)) { IFCAnyHandle assemblyInstanceHnd = null; string guid = GUIDUtil.CreateGUID(element); IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle(); string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element)); string description = NamingUtil.GetDescriptionOverride(element, null); string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName()); IFCAnyHandle localPlacement = null; PlacementSetter placementSetter = null; IFCLevelInfo levelInfo = null; string ifcEnumType; IFCExportType exportAs = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType); if (exportAs == IFCExportType.IfcSystem) { assemblyInstanceHnd = IFCInstanceExporter.CreateSystem(file, guid, ownerHistory, name, description, objectType); // Create classification reference when System has classification filed name assigned to it ClassificationUtil.CreateClassification(exporterIFC, file, element, assemblyInstanceHnd); HashSet <IFCAnyHandle> relatedBuildings = new HashSet <IFCAnyHandle>(); relatedBuildings.Add(ExporterCacheManager.BuildingHandle); IFCAnyHandle relServicesBuildings = IFCInstanceExporter.CreateRelServicesBuildings(file, GUIDUtil.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(), null, null, assemblyInstanceHnd, relatedBuildings); } else { using (placementSetter = PlacementSetter.Create(exporterIFC, element)) { string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element)); IFCAnyHandle representation = null; // We have limited support for exporting assemblies as other container types. localPlacement = placementSetter.LocalPlacement; levelInfo = placementSetter.LevelInfo; ifcEnumType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType); switch (exportAs) { case IFCExportType.IfcCurtainWall: assemblyInstanceHnd = IFCInstanceExporter.CreateCurtainWall(file, guid, ownerHistory, name, description, objectType, localPlacement, representation, elementTag); break; case IFCExportType.IfcRamp: string rampPredefinedType = RampExporter.GetIFCRampType(ifcEnumType); assemblyInstanceHnd = IFCInstanceExporter.CreateRamp(file, guid, ownerHistory, name, description, objectType, localPlacement, representation, elementTag, rampPredefinedType); break; case IFCExportType.IfcRoof: assemblyInstanceHnd = IFCInstanceExporter.CreateRoof(file, guid, ownerHistory, name, description, objectType, localPlacement, representation, elementTag, ifcEnumType); break; case IFCExportType.IfcStair: string stairPredefinedType = StairsExporter.GetIFCStairType(ifcEnumType); assemblyInstanceHnd = IFCInstanceExporter.CreateStair(file, guid, ownerHistory, name, description, objectType, localPlacement, representation, elementTag, stairPredefinedType); break; case IFCExportType.IfcWall: assemblyInstanceHnd = IFCInstanceExporter.CreateWall(file, guid, ownerHistory, name, description, objectType, localPlacement, representation, elementTag, ifcEnumType); break; default: IFCElementAssemblyType assemblyPredefinedType = GetPredefinedTypeFromObjectType(objectType); assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(file, guid, ownerHistory, name, description, objectType, localPlacement, representation, elementTag, IFCAssemblyPlace.NotDefined, assemblyPredefinedType); break; } } } if (assemblyInstanceHnd == null) { return(false); } bool relateToLevel = (levelInfo != null); productWrapper.AddElement(element, assemblyInstanceHnd, levelInfo, null, relateToLevel); ExporterCacheManager.AssemblyInstanceCache.RegisterAssemblyInstance(element.Id, assemblyInstanceHnd); tr.Commit(); return(true); } }