/// <summary> /// Get an IFC Profile Name from the FamilySymbol (the type) name, or from the override parameter of the type "IfcProfileName[Type]" /// </summary> /// <param name="element">the element (Instance/FamilyInstance or Type/FamilySymbol)</param> /// <returns>the profile name</returns> public static string GetProfileName(Element element, string originalName = null) { FamilySymbol fSymb; if (element is FamilyInstance) { fSymb = (element as FamilyInstance).Symbol; } else { fSymb = element as FamilySymbol; } if (fSymb == null) { return(originalName); } // Get a profile name. It is by default set to the type (familySymbol) name, but can be overridden by IfcProfileName[Type] shared parameter string profileName = fSymb.Name; string profile; ParameterUtil.GetStringValueFromElement(fSymb, "IfcProfileName[Type]", out profile); if (!string.IsNullOrEmpty(profile)) { profileName = profile; } if (string.IsNullOrEmpty(profileName)) { return(originalName); } return(profileName); }
/// <summary> /// Gets override string value from element parameter. /// </summary> /// <param name="element"> /// The element. /// </param> /// <param name="paramName"> /// The parameter name. /// </param> /// <param name="originalValue"> /// The original value. /// </param> /// <returns> /// The string contains the string value. /// </returns> public static string GetOverrideStringValue(Element element, string paramName, string originalValue) { //string strValue; string paramValue; if (element != null) { if (ParameterUtil.GetStringValueFromElement(element, paramName, out paramValue) != null && !string.IsNullOrEmpty(paramValue)) { string propertyValue = null; object strValue = null; ParamExprResolver.CheckForParameterExpr(paramValue, element, paramName, ParamExprResolver.ExpectedValueEnum.STRINGVALUE, out strValue); if (strValue != null && strValue is string) { propertyValue = strValue as string; } else { propertyValue = paramValue; // return the original paramValue } return(propertyValue); } } return(originalValue); }
/// <summary> /// Gets override string value from element parameter. /// </summary> /// <param name="element"> /// The element. /// </param> /// <param name="paramName"> /// The parameter name. /// </param> /// <param name="originalValue"> /// The original value. /// </param> /// <returns> /// The string contains the string value. /// </returns> public static string GetOverrideStringValue(Element element, string paramName, string originalValue) { //string strValue; string paramValue; if (element != null) { if (ParameterUtil.GetStringValueFromElement(element, paramName, out paramValue) != null && !string.IsNullOrEmpty(paramValue)) { string propertyValue = null; string paramValuetrim = paramValue.Trim(); // This is kind of hack to quickly check whether we need to parse the parameter or not by checking that the value is enclosed by "{ }" or "u{ }" for unique value if (((paramValuetrim.Length > 1 && paramValuetrim[0] == '{') || (paramValuetrim.Length > 2 && paramValuetrim[1] == '{')) && (paramValuetrim[paramValuetrim.Length - 1] == '}')) { ParamExprResolver pResv = new ParamExprResolver(element, paramName, paramValuetrim); propertyValue = pResv.GetStringValue(); if (string.IsNullOrEmpty(propertyValue)) { propertyValue = paramValue; // return the original paramValue } } else { propertyValue = paramValue; // return the original paramValue } //return paramValue; return(propertyValue); } } return(originalValue); }
/// <summary> /// Creates a Project, Site, or Building GUID. If a shared parameter is set with a valid IFC GUID value, /// that value will override the default one. /// </summary> /// <param name="document">The document.</param> /// <param name="guidType">The GUID being created.</param> /// <returns>The IFC GUID value.</returns> /// <remarks>For Sites, the user should only use this routine if there is no Site element in the file. Otherwise, they /// should use CreateSiteGUID below, which takes an Element pointer.</remarks> static public string CreateProjectLevelGUID(Document document, IFCProjectLevelGUIDType guidType) { string parameterName = "Ifc" + guidType.ToString() + " GUID"; ProjectInfo projectInfo = document.ProjectInformation; BuiltInParameter parameterId = BuiltInParameter.INVALID; switch (guidType) { case IFCProjectLevelGUIDType.Building: parameterId = BuiltInParameter.IFC_BUILDING_GUID; break; case IFCProjectLevelGUIDType.Project: parameterId = BuiltInParameter.IFC_PROJECT_GUID; break; case IFCProjectLevelGUIDType.Site: parameterId = BuiltInParameter.IFC_SITE_GUID; break; default: // This should eventually log an error. return(null); } if (projectInfo != null) { string paramValue = null; ParameterUtil.GetStringValueFromElement(projectInfo, parameterName, out paramValue); if (!IsValidIFCGUID(paramValue) && parameterId != BuiltInParameter.INVALID) { ParameterUtil.GetStringValueFromElement(projectInfo, parameterId, out paramValue); } if (IsValidIFCGUID(paramValue)) { return(paramValue); } } // Only for 2022 //ElementId projectLevelElementId = new ElementId((int)guidType); //System.Guid guid = ExportUtils.GetExportId(document, projectLevelElementId); //string ifcGUID = ConvertToIFCGuid(guid); string ifcGUID = ExporterIFCUtils.CreateProjectLevelGUID(document, guidType); if ((projectInfo != null) && ExporterCacheManager.ExportOptionsCache.GUIDOptions.StoreIFCGUID) { if (parameterId != BuiltInParameter.INVALID) { ExporterCacheManager.GUIDsToStoreCache[new KeyValuePair <ElementId, BuiltInParameter>(projectInfo.Id, parameterId)] = ifcGUID; } } return(ifcGUID); }
/// <summary> /// Get override containment value through a parameter "IfcSpatialContainer" or "OverrideElementContainer". Value can be "IFCSITE", "IFCBUILDING", or the appropriate Level name /// </summary> /// <param name="element">the element</param> /// <param name="overrideContainerHnd">the override container Handle</param> /// <returns>true if there is override</returns> public static ElementId OverrideContainmentParameter(ExporterIFC exporterIFC, Element element, out IFCAnyHandle overrideContainerHnd) { ElementId containerElemId = ElementId.InvalidElementId; // Special case whether an object should be assigned to the Site or Building container overrideContainerHnd = null; string containerOverrideName = null; if (ParameterUtil.GetStringValueFromElement(element, "OverrideElementContainer", out containerOverrideName) == null) { ParameterUtil.GetStringValueFromElement(element, "IfcSpatialContainer", out containerOverrideName); } if (!string.IsNullOrEmpty(containerOverrideName)) { if (containerOverrideName.Equals("IFCSITE", StringComparison.CurrentCultureIgnoreCase)) { overrideContainerHnd = ExporterCacheManager.SiteHandle; return(containerElemId); } else if (containerOverrideName.Equals("IFCBUILDING", StringComparison.CurrentCultureIgnoreCase)) { overrideContainerHnd = ExporterCacheManager.BuildingHandle; return(containerElemId); } // Find Level that is designated as the override by iterating through all the Levels for the name match FilteredElementCollector collector = new FilteredElementCollector(element.Document); ICollection <Element> collection = collector.OfClass(typeof(Level)).ToElements(); foreach (Element level in collection) { if (level.Name.Equals(containerOverrideName, StringComparison.CurrentCultureIgnoreCase)) { containerElemId = level.Id; break; } } if (containerElemId != ElementId.InvalidElementId) { IFCLevelInfo levelInfo = ExporterCacheManager.LevelInfoCache.GetLevelInfo(exporterIFC, containerElemId); if (levelInfo != null) { overrideContainerHnd = levelInfo.GetBuildingStorey(); } if (overrideContainerHnd != null) { return(containerElemId); } } } return(containerElemId); }
/// <summary> /// Creates a Site GUID for a Site element. If "IfcSite GUID" is set to a valid IFC GUID /// in the site element, that value will override any value stored in ProjectInformation. /// </summary> /// <param name="document">The document pointer.</param> /// <param name="element">The Site element.</param> /// <returns>The GUID as a string.</returns> static public string CreateSiteGUID(Document document, Element element) { if (element != null) { ParameterUtil.GetStringValueFromElement(element, "IfcSiteGUID", out string paramValue); if (IsValidIFCGUID(paramValue)) { return(paramValue); } } return(CreateProjectLevelGUID(document, ProjectLevelGUIDType.Site)); }
/// <summary> /// Creates a Site GUID for a Site element. If "IfcSite GUID" is set to a valid IFC GUID in Project Information, that value will /// override the default GUID generation for the Site element. /// </summary> /// <param name="document">The document pointer.</param> /// <param name="element">The Site element.</param> /// <returns></returns> static public string CreateSiteGUID(Document document, Element element) { ProjectInfo projectInfo = document.ProjectInformation; if (projectInfo != null) { string paramValue = null; ParameterUtil.GetStringValueFromElement(projectInfo.Id, "IfcSiteGUID", out paramValue); if ((paramValue != null) && (IsValidIFCGUID(paramValue))) { return(paramValue); } } return(CreateGUID(element)); }
/// <summary> /// Creates a Project, Site, or Building GUID. If a shared parameter is set with a valid IFC GUID value, /// that value will override the default one. /// </summary> /// <param name="document">The document.</param> /// <param name="guidType">The GUID being created.</param> /// <returns>The IFC GUID value.</returns> /// <remarks>For Sites, the user should only use this routine if there is no Site element in the file. Otherwise, they /// should use CreateSiteGUID below, which takes an Element pointer.</remarks> static public string CreateProjectLevelGUID(Document document, IFCProjectLevelGUIDType guidType) { string parameterName = "Ifc" + guidType.ToString() + " GUID"; ProjectInfo projectInfo = document.ProjectInformation; BuiltInParameter parameterId = BuiltInParameter.INVALID; switch (guidType) { case IFCProjectLevelGUIDType.Building: parameterId = BuiltInParameter.IFC_BUILDING_GUID; break; case IFCProjectLevelGUIDType.Project: parameterId = BuiltInParameter.IFC_PROJECT_GUID; break; case IFCProjectLevelGUIDType.Site: parameterId = BuiltInParameter.IFC_SITE_GUID; break; } if (projectInfo != null) { string paramValue = null; ParameterUtil.GetStringValueFromElement(projectInfo, parameterName, out paramValue); if ((paramValue != null) && (IsValidIFCGUID(paramValue))) { return(paramValue); } if (parameterId != BuiltInParameter.INVALID && ParameterUtil.GetStringValueFromElement(projectInfo, parameterId, out paramValue) != null) { return(paramValue); } } string guid = ExporterIFCUtils.CreateProjectLevelGUID(document, guidType); if ((projectInfo != null) && ExporterCacheManager.ExportOptionsCache.GUIDOptions.StoreIFCGUID) { if (parameterId != BuiltInParameter.INVALID) { ExporterCacheManager.GUIDsToStoreCache[new KeyValuePair <Element, BuiltInParameter>(projectInfo, parameterId)] = guid; } } return(guid); }
static private string CreateGUIDBase(Element element, BuiltInParameter parameterName, out bool shouldStore) { shouldStore = false; string ifcGUID = null; if (ExporterCacheManager.ExportOptionsCache.GUIDOptions.AllowGUIDParameterOverride) { ParameterUtil.GetStringValueFromElement(element, parameterName, out ifcGUID); } if (!IsValidIFCGUID(ifcGUID)) { System.Guid guid = ExportUtils.GetExportId(element.Document, element.Id); ifcGUID = ConvertToIFCGuid(guid); shouldStore = true; } return(ifcGUID); }
/// <summary> /// Gets override string value from element parameter. /// </summary> /// <param name="element"> /// The element. /// </param> /// <param name="paramName"> /// The parameter name. /// </param> /// <param name="originalValue"> /// The original value. /// </param> /// <returns> /// The string contains the string value. /// </returns> public static string GetOverrideStringValue(Element element, string paramName, string originalValue) { string strValue; // get the IFC Name Override if (element != null) { if (ParameterUtil.GetStringValueFromElement(element.Id, paramName, out strValue) != null) { if (!String.IsNullOrWhiteSpace(strValue)) { return(strValue); } } } return(originalValue); }
/// <summary> /// Gets override string value from element parameter. /// </summary> /// <param name="element"> /// The element. /// </param> /// <param name="paramName"> /// The parameter name. /// </param> /// <param name="originalValue"> /// The original value. /// </param> /// <returns> /// The string contains the string value. /// </returns> public static string GetOverrideStringValue(Element element, string paramName, string originalValue) { string strValue; if (element != null) { if (ParameterUtil.GetStringValueFromElement(element.Id, paramName, out strValue) != null) { // Returns a string value from the parameter of an element. // If the string is empty, it returns the originalValue. if (!String.IsNullOrWhiteSpace(strValue)) { return(strValue); } } } return(originalValue); }
static private string CreateGUIDBase(Element element, BuiltInParameter parameterName, out bool shouldStore) { string ifcGUID = null; shouldStore = CanStoreGUID(element); // Avoid getting into an object if the object is part of the Group. It may cause regrenerate that invalidate other ElementIds if (shouldStore && ExporterCacheManager.ExportOptionsCache.GUIDOptions.AllowGUIDParameterOverride) { ParameterUtil.GetStringValueFromElement(element, parameterName, out ifcGUID); } if (!IsValidIFCGUID(ifcGUID)) { ifcGUID = CreateSimpleGUID(element); } return(ifcGUID); }
private void CalculateDoorWindowInformation(ExporterIFC exporterIFC, FamilyInstance famInst, ElementId overrideLevelId, Transform trf) { IFCFile file = exporterIFC.GetFile(); if (ExportingDoor) { string doorOperationType = null; Element doorType = famInst.Document.GetElement(famInst.GetTypeId()); if (doorType != null) { // Look at the "Operation" override first, then the built-in parameter. ParameterUtil.GetStringValueFromElementOrSymbol(doorType, "Operation", out doorOperationType); if (!string.IsNullOrWhiteSpace(doorOperationType)) { ParameterUtil.GetStringValueFromElement(doorType, BuiltInParameter.DOOR_OPERATION_TYPE, out doorOperationType); } } DoorOperationTypeString = "NOTDEFINED"; if (!string.IsNullOrWhiteSpace(doorOperationType)) { Type enumType = null; if (ExporterCacheManager.ExportOptionsCache.ExportAs4) { enumType = typeof(Toolkit.IFC4.IFCDoorStyleOperation); } else { enumType = typeof(Toolkit.IFCDoorStyleOperation); } foreach (Enum ifcDoorStyleOperation in Enum.GetValues(enumType)) { string enumAsString = ifcDoorStyleOperation.ToString(); if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(enumAsString, doorOperationType)) { DoorOperationTypeString = enumAsString; break; } } } if (DoorOperationTypeString == "NOTDEFINED") { // We are going to try to guess the hinge placement. DoorOperationTypeString = CalculateDoorOperationStyle(famInst); } if (FlippedX ^ FlippedY) { DoorOperationTypeString = ReverseDoorStyleOperation(DoorOperationTypeString); } if (String.Compare(DoorOperationTypeString, "USERDEFINED", true) == 0) { string userDefinedOperationType; ParameterUtil.GetStringValueFromElementOrSymbol(doorType, "UserDefinedOperationType", out userDefinedOperationType); if (!string.IsNullOrEmpty(userDefinedOperationType)) { UserDefinedOperationType = userDefinedOperationType; } else { DoorOperationTypeString = "NOTDEFINED"; //re-set to NotDefined if operation type is set to UserDefined but the userDefinedOperationType parameter is empty! } } } if (HasRealWallHost) { // do hingeside calculation Wall wall = HostObject as Wall; PosHingeSide = true; BoundingBoxXYZ famBBox = null; Options options = GeometryUtil.GetIFCExportGeometryOptions(); GeometryElement geomElement = famInst.GetOriginalGeometry(options); if (geomElement != null) { famBBox = geomElement.GetBoundingBox(); } if (famBBox != null) { XYZ bboxCtr = trf.OfPoint((famBBox.Min + famBBox.Max) / 2.0); Curve curve = WallExporter.GetWallAxis(wall); XYZ wallZDir = WallExporter.GetWallHeightDirection(wall); // famInst.HostParameter will fail if FamilyPlacementType is WorkPlaneBased, regardless of whether or not the reported host is a Wall. // In this case, just use the start parameter of the curve. bool hasHostParameter = famInst.Symbol.Family.FamilyPlacementType != FamilyPlacementType.WorkPlaneBased; double param = hasHostParameter ? famInst.HostParameter : curve.GetEndParameter(0); Transform wallTrf = curve.ComputeDerivatives(param, false); XYZ wallOrig = wallTrf.Origin; XYZ wallXDir = wallTrf.BasisX; XYZ wallYDir = wallZDir.CrossProduct(wallXDir); double eps = MathUtil.Eps(); bboxCtr -= wallOrig; PosHingeSide = (bboxCtr.DotProduct(wallYDir) > -eps); XYZ famInstYDir = trf.BasisY; FlippedSymbol = (PosHingeSide != (wallYDir.DotProduct(famInstYDir) > -eps)); } } }