/// <summary> /// Processes an IFC unit in the property. /// </summary> /// <param name="ifcSimpleProperty">The simple property.</param> /// <param name="simplePropertyHandle">The simple property handle.</param> static protected void ProcessIFCSimplePropertyUnit(IFCSimpleProperty ifcSimpleProperty, IFCAnyHandle simplePropertyHandle) { IFCAnyHandle ifcUnitHandle = IFCImportHandleUtil.GetOptionalInstanceAttribute(simplePropertyHandle, "Unit"); IFCUnit ifcUnit = (ifcUnitHandle != null) ? IFCUnit.ProcessIFCUnit(ifcUnitHandle) : null; if (ifcUnit == null) { if (ifcSimpleProperty.IFCPropertyValues.Count > 0) { IFCPropertyValue propertyValue = ifcSimpleProperty.IFCPropertyValues[0]; if (propertyValue != null && propertyValue.HasValue() && (propertyValue.Type == IFCDataPrimitiveType.Integer) || (propertyValue.Type == IFCDataPrimitiveType.Double)) { string unitTypeName; UnitType unitType = IFCDataUtil.GetUnitTypeFromData(propertyValue.Value, UnitType.UT_Undefined, out unitTypeName); if (unitType != UnitType.UT_Undefined) { ifcUnit = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(unitType); } else { Importer.TheLog.LogWarning(simplePropertyHandle.StepId, "Unhandled unit type: " + unitTypeName, true); } } } } ifcSimpleProperty.m_IFCUnit = ifcUnit; }
/// <summary> /// Processes an IFC physical simple quantity. /// </summary> /// <param name="ifcPhysicalQuantity">The IfcPhysicalSimpleQuantity object.</param> /// <returns>The IFCPhysicalSimpleQuantity object.</returns> override protected void Process(IFCAnyHandle ifcPhysicalSimpleQuantity) { base.Process(ifcPhysicalSimpleQuantity); IFCAnyHandle unit = IFCImportHandleUtil.GetOptionalInstanceAttribute(ifcPhysicalSimpleQuantity, "Unit"); if (!IFCAnyHandleUtil.IsNullOrHasNoValue(unit)) { IFCUnit = IFCUnit.ProcessIFCUnit(unit); } // Process subtypes of IfcPhysicalSimpleQuantity here. string attributeName = ifcPhysicalSimpleQuantity.TypeName.Substring(11) + "Value"; Value = ifcPhysicalSimpleQuantity.GetAttribute(attributeName); BaseUnitType = IFCDataUtil.GetUnitTypeFromData(Value, UnitType.UT_Undefined); if (BaseUnitType == UnitType.UT_Undefined) { // Determine it from the attributeName. if (string.Compare(attributeName, "LengthValue", true) == 0) { BaseUnitType = UnitType.UT_Length; } else if (string.Compare(attributeName, "AreaValue", true) == 0) { BaseUnitType = UnitType.UT_Area; } else if (string.Compare(attributeName, "VolumeValue", true) == 0) { BaseUnitType = UnitType.UT_Volume; } else if (string.Compare(attributeName, "CountValue", true) == 0) { BaseUnitType = UnitType.UT_Number; } else if (string.Compare(attributeName, "WeightValue", true) == 0) { BaseUnitType = UnitType.UT_Mass; } else if (string.Compare(attributeName, "TimeValue", true) == 0) { BaseUnitType = UnitType.UT_Number; // No time unit type in Revit. } else { Importer.TheLog.LogWarning(Id, "Can't determine unit type for IfcPhysicalSimpleQuantity of type: " + attributeName, true); BaseUnitType = UnitType.UT_Number; } } if (IFCUnit == null) { IFCUnit = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(BaseUnitType); } }
/// <summary> /// Create a label property. /// </summary> /// <param name="file">The IFC file.</param> /// <param name="propertyName">The name of the property.</param> /// <param name="value">The value of the property.</param> /// <param name="valueType">The value type of the property.</param> /// <returns>The created property handle.</returns> public static IFCAnyHandle CreateElectricalCurrentMeasureProperty(IFCFile file, string propertyName, double value, PropertyValueType valueType) { switch (valueType) { case PropertyValueType.EnumeratedValue: { IList <IFCData> valueList = new List <IFCData>(); valueList.Add(IFCDataUtil.CreateAsElectricalCurrentMeasure(value)); return(IFCInstanceExporter.CreatePropertyEnumeratedValue(file, propertyName, null, valueList, null)); } case PropertyValueType.SingleValue: return(IFCInstanceExporter.CreatePropertySingleValue(file, propertyName, null, IFCDataUtil.CreateAsElectricalCurrentMeasure(value), null)); default: throw new InvalidOperationException("Missing case!"); } }
public static IFCAnyHandle GetOrCreateMaterialStyle(Document document, ExporterIFC exporterIFC, ElementId materialId) { IFCAnyHandle styleHnd = ExporterCacheManager.MaterialIdToStyleHandleCache.Find(materialId); if (styleHnd == null) { Material material = document.GetElement(materialId) as Material; if (material == null) { return(null); } string matName = material.Name; Color color = material.Color; double blueVal = color.Blue / 255.0; double greenVal = color.Green / 255.0; double redVal = color.Red / 255.0; IFCFile file = exporterIFC.GetFile(); IFCAnyHandle colorHnd = IFCInstanceExporter.CreateColourRgb(file, null, redVal, greenVal, blueVal); double transparency = ((double)material.Transparency) / 100.0; IFCData smoothness = IFCDataUtil.CreateAsNormalisedRatioMeasure(((double)material.Smoothness) / 100.0); IFCData specularExp = IFCDataUtil.CreateAsSpecularExponent(material.Shininess); IFCReflectanceMethod method = IFCReflectanceMethod.NotDefined; IFCAnyHandle renderingHnd = IFCInstanceExporter.CreateSurfaceStyleRendering(file, colorHnd, transparency, null, null, null, null, smoothness, specularExp, method); ICollection <IFCAnyHandle> surfStyles = new HashSet <IFCAnyHandle>(); surfStyles.Add(renderingHnd); IFCSurfaceSide surfSide = IFCSurfaceSide.Both; styleHnd = IFCInstanceExporter.CreateSurfaceStyle(file, matName, surfSide, surfStyles); ExporterCacheManager.MaterialIdToStyleHandleCache.Register(materialId, styleHnd); } return(styleHnd); }
/// <summary> /// Create a label property. /// </summary> /// <param name="file">The IFC file.</param> /// <param name="propertyName">The name of the property.</param> /// <param name="value">The value of the property.</param> /// <param name="valueType">The value type of the property.</param> /// <returns>The created property handle.</returns> public static IFCAnyHandle CreatePositivePlaneAngleMeasureProperty(IFCFile file, string propertyName, double value, PropertyValueType valueType) { // Ensure it is positive. Don't throw, but should tell user. if (value <= MathUtil.Eps()) { return(null); } switch (valueType) { case PropertyValueType.EnumeratedValue: { IList <IFCData> valueList = new List <IFCData>(); valueList.Add(IFCDataUtil.CreateAsPositivePlaneAngleMeasure(value)); return(IFCInstanceExporter.CreatePropertyEnumeratedValue(file, propertyName, null, valueList, null)); } case PropertyValueType.SingleValue: return(IFCInstanceExporter.CreatePropertySingleValue(file, propertyName, null, IFCDataUtil.CreateAsPositivePlaneAngleMeasure(value), null)); default: throw new InvalidOperationException("Missing case!"); } }
/// <summary> /// Create a quantity for a given element. /// </summary> /// <param name="doc">The document.</param> /// <param name="element">The element being created.</param> /// <param name="parameterMap">The parameters of the element. Cached for performance.</param> /// <param name="propertySetName">The name of the containing property set.</param> /// <param name="createdParameters">The names of the created parameters.</param> public override void Create(Document doc, Element element, IFCParameterSetByGroup parameterGroupMap, string propertySetName, ISet <string> createdParameters) { double doubleValueToUse = IFCUnit != null?IFCUnit.Convert(Value.AsDouble()) : Value.AsDouble(); Parameter existingParameter = null; string originalParameterName = Name + "(" + propertySetName + ")"; string parameterName = originalParameterName; if (!parameterGroupMap.TryFindParameter(parameterName, out existingParameter)) { int parameterNameCount = 2; while (createdParameters.Contains(parameterName)) { parameterName = originalParameterName + " " + parameterNameCount; parameterNameCount++; } if (parameterNameCount > 2) { Importer.TheLog.LogWarning(Id, "Renamed parameter: " + originalParameterName + " to: " + parameterName, false); } if (existingParameter == null) { UnitType unitType = UnitType.UT_Undefined; if (IFCUnit != null) { unitType = IFCUnit.UnitType; } else { unitType = IFCDataUtil.GetUnitTypeFromData(Value, UnitType.UT_Number); } bool created = IFCPropertySet.AddParameterDouble(doc, element, parameterName, unitType, doubleValueToUse, Id); if (created) { createdParameters.Add(parameterName); } return; } } bool setValue = true; switch (existingParameter.StorageType) { case StorageType.String: existingParameter.Set(doubleValueToUse.ToString()); break; case StorageType.Double: existingParameter.Set(doubleValueToUse); break; default: setValue = false; break; } if (!setValue) { Importer.TheLog.LogError(Id, "Couldn't create parameter: " + Name + " of storage type: " + existingParameter.StorageType.ToString(), false); } }
/// <summary> /// Get the handles of Grid Axes. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="sameDirectionAxes">The grid axes in the same direction of one level.</param> /// <param name="representations">The representation of grid axis.</param> /// <returns>The list of handles of grid axes.</returns> private static List <IFCAnyHandle> CreateIFCGridAxisAndRepresentations(ExporterIFC exporterIFC, ProductWrapper productWrapper, IList <Grid> sameDirectionAxes, IList <IFCAnyHandle> representations, GridRepresentationData gridRepresentationData) { if (sameDirectionAxes.Count == 0) { return(null); } IDictionary <ElementId, List <IFCAnyHandle> > gridAxisMap = new Dictionary <ElementId, List <IFCAnyHandle> >(); IDictionary <ElementId, List <IFCAnyHandle> > gridRepMap = new Dictionary <ElementId, List <IFCAnyHandle> >(); IFCFile ifcFile = exporterIFC.GetFile(); Grid baseGrid = sameDirectionAxes[0]; Transform lcs = Transform.Identity; List <IFCAnyHandle> ifcGridAxes = new List <IFCAnyHandle>(); foreach (Grid grid in sameDirectionAxes) { // Because the IfcGrid is a collection of Revit Grids, any one of them can override the IFC CAD Layer. // We will take the first name, and not do too much checking. if (string.IsNullOrWhiteSpace(gridRepresentationData.m_IFCCADLayer)) { ParameterUtil.GetStringValueFromElementOrSymbol(grid, "IFCCadLayer", out gridRepresentationData.m_IFCCADLayer); } // Get the handle of curve. XYZ projectionDirection = lcs.BasisZ; IFCAnyHandle axisCurve; if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView) { axisCurve = GeometryUtil.CreatePolyCurveFromCurve(exporterIFC, grid.Curve, lcs, projectionDirection); } else { IFCGeometryInfo info = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, lcs, projectionDirection, false); ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, grid.Curve, XYZ.Zero, false); IList <IFCAnyHandle> curves = info.GetCurves(); if (curves.Count != 1) { throw new Exception("IFC: expected 1 curve when export curve element."); } axisCurve = curves[0]; } bool sameSense = true; if (baseGrid.Curve is Line) { Line baseLine = baseGrid.Curve as Line; Line axisLine = grid.Curve as Line; sameSense = (axisLine.Direction.IsAlmostEqualTo(baseLine.Direction)); } IFCAnyHandle ifcGridAxis = IFCInstanceExporter.CreateGridAxis(ifcFile, grid.Name, axisCurve, sameSense); ifcGridAxes.Add(ifcGridAxis); HashSet <IFCAnyHandle> AxisCurves = new HashSet <IFCAnyHandle>(); AxisCurves.Add(axisCurve); IFCAnyHandle repItemHnd = IFCInstanceExporter.CreateGeometricCurveSet(ifcFile, AxisCurves); // get the weight and color from the GridType to create the curve style. GridType gridType = grid.Document.GetElement(grid.GetTypeId()) as GridType; IFCData curveWidth = null; if (ExporterCacheManager.ExportOptionsCache.ExportAnnotations) { int outWidth; double width = (ParameterUtil.GetIntValueFromElement(gridType, BuiltInParameter.GRID_END_SEGMENT_WEIGHT, out outWidth) != null) ? outWidth : 1; curveWidth = IFCDataUtil.CreateAsPositiveLengthMeasure(width); } if (!ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView) { int outColor; int color = (ParameterUtil.GetIntValueFromElement(gridType, BuiltInParameter.GRID_END_SEGMENT_COLOR, out outColor) != null) ? outColor : 0; double blueVal = 0.0; double greenVal = 0.0; double redVal = 0.0; GeometryUtil.GetRGBFromIntValue(color, out blueVal, out greenVal, out redVal); IFCAnyHandle colorHnd = IFCInstanceExporter.CreateColourRgb(ifcFile, null, redVal, greenVal, blueVal); BodyExporter.CreateCurveStyleForRepItem(exporterIFC, repItemHnd, curveWidth, colorHnd); } HashSet <IFCAnyHandle> curveSet = new HashSet <IFCAnyHandle>(); curveSet.Add(repItemHnd); gridRepresentationData.m_Grids.Add(grid); gridRepresentationData.m_curveSets.Add(curveSet); } return(ifcGridAxes); }
/// <summary> /// Creates IfcPresentationStyleAssignment for text element type. /// </summary> /// <param name="exporterIFC"> /// The ExporterIFC object. /// </param> /// <param name="textElemType"> /// The text note element type. /// </param> /// <param name="cache"> /// The cache of IfcPresentationStyleAssignment. /// </param> static void CreatePresentationStyleAssignmentForTextElementType(ExporterIFC exporterIFC, TextElementType textElemType, PresentationStyleAssignmentCache cache) { IFCFile file = exporterIFC.GetFile(); string fontName; if (ParameterUtil.GetStringValueFromElement(textElemType, BuiltInParameter.TEXT_FONT, out fontName) == null) { fontName = null; } double fontSize; if (ParameterUtil.GetDoubleValueFromElement(textElemType, BuiltInParameter.TEXT_SIZE, out fontSize) == null) { fontSize = -1.0; } double viewScale = 100.0; // currently hardwired. fontSize = UnitUtil.ScaleLength(fontSize * viewScale); string ifcPreDefinedItemName = "Text Font"; IList <string> fontNameList = new List <string>(); fontNameList.Add(fontName); IFCAnyHandle textSyleFontModelHnd = IFCInstanceExporter.CreateTextStyleFontModel(file, ifcPreDefinedItemName, fontNameList, null, null, null, IFCDataUtil.CreateAsPositiveLengthMeasure(fontSize)); int color; ParameterUtil.GetIntValueFromElement(textElemType, BuiltInParameter.LINE_COLOR, out color); double blueVal = ((double)((color & 0xff0000) >> 16)) / 255.0; double greenVal = ((double)((color & 0xff00) >> 8)) / 255.0; double redVal = ((double)(color & 0xff)) / 255.0; IFCAnyHandle colorHnd = IFCInstanceExporter.CreateColourRgb(file, null, redVal, greenVal, blueVal); IFCAnyHandle fontColorHnd = IFCInstanceExporter.CreateTextStyleForDefinedFont(file, colorHnd, null); string ifcAttrName = textElemType.Name; IFCAnyHandle textStyleHnd = IFCInstanceExporter.CreateTextStyle(file, textElemType.Name, fontColorHnd, null, textSyleFontModelHnd); if (IFCAnyHandleUtil.IsNullOrHasNoValue(textStyleHnd)) { return; } HashSet <IFCAnyHandle> presStyleSet = new HashSet <IFCAnyHandle>(); presStyleSet.Add(textStyleHnd); IFCAnyHandle presStyleHnd = IFCInstanceExporter.CreatePresentationStyleAssignment(file, presStyleSet); if (IFCAnyHandleUtil.IsNullOrHasNoValue(presStyleHnd)) { return; } cache.Register(textElemType.Id, presStyleHnd); }
/// <summary> /// Create a property for a given element. /// </summary> /// <param name="doc">The document.</param> /// <param name="element">The element being created.</param> /// <param name="category">The category of the element being created.</param> /// <param name="parameterMap">The parameters of the element. Cached for performance.</param> /// <param name="propertySetName">The name of the containing property set.</param> /// <param name="createdParameters">The names of the created parameters.</param> public void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap, string propertySetName, ISet <string> createdParameters) { // Try to get the single value from the property. If we can't get a single value, get it as a string. IFCPropertyValue propertyValueToUse = null; if (this is IFCSimpleProperty) { IFCSimpleProperty simpleProperty = this as IFCSimpleProperty; IList <IFCPropertyValue> propertyValues = simpleProperty.IFCPropertyValues; if (propertyValues != null && propertyValues.Count == 1) { // If the value isn't set, skip it. We won't warn. if (!propertyValues[0].HasValue()) { return; } propertyValueToUse = propertyValues[0]; } } IFCDataPrimitiveType dataType = IFCDataPrimitiveType.Unknown; ForgeTypeId specTypeId = new ForgeTypeId(); ForgeTypeId unitsTypeId = null; bool? boolValueToUse = null; IFCLogical?logicalValueToUse = null; int? intValueToUse = null; double? doubleValueToUse = null; ElementId elementIdValueToUse = null; string stringValueToUse = null; if (propertyValueToUse == null) { string propertyValueAsString = PropertyValueAsString(); if (propertyValueAsString == null) { Importer.TheLog.LogError(Id, "Couldn't create parameter: " + Name, false); return; } dataType = IFCDataPrimitiveType.String; stringValueToUse = propertyValueAsString; } else { dataType = propertyValueToUse.Value.PrimitiveType; if (dataType == IFCDataPrimitiveType.Instance) { IFCAnyHandle propertyValueHandle = propertyValueToUse.Value.AsInstance(); ElementId propertyValueAsId = IFCObjectReferenceSelect.ToElementId(propertyValueHandle); if (propertyValueAsId != ElementId.InvalidElementId) { elementIdValueToUse = propertyValueAsId; } else { stringValueToUse = IFCObjectReferenceSelect.ToString(propertyValueHandle); dataType = IFCDataPrimitiveType.String; } } else { switch (dataType) { case IFCDataPrimitiveType.String: case IFCDataPrimitiveType.Enumeration: case IFCDataPrimitiveType.Binary: stringValueToUse = propertyValueToUse.AsString(); break; case IFCDataPrimitiveType.Integer: intValueToUse = propertyValueToUse.AsInteger(); break; case IFCDataPrimitiveType.Boolean: boolValueToUse = propertyValueToUse.AsBoolean(); break; case IFCDataPrimitiveType.Logical: logicalValueToUse = propertyValueToUse.AsLogical(); break; case IFCDataPrimitiveType.Double: if (propertyValueToUse.IFCUnit != null) { specTypeId = propertyValueToUse.IFCUnit.Spec; unitsTypeId = propertyValueToUse.IFCUnit.Unit; } else { specTypeId = IFCDataUtil.GetUnitTypeFromData(propertyValueToUse.Value, SpecTypeId.Number); } doubleValueToUse = Importer.TheProcessor.ScaleValues ? propertyValueToUse.AsScaledDouble() : propertyValueToUse.AsUnscaledDouble(); break; default: Importer.TheLog.LogError(Id, "Unknown value type for parameter: " + Name, false); return; } } } if (stringValueToUse != null && stringValueToUse.Length == 0) { return; } Parameter existingParameter = null; bool elementIsType = (element is ElementType); string typeString = elementIsType ? " " + Resources.IFCTypeSchedule : string.Empty; string originalParameterName = propertySetName + "." + Name + typeString; string parameterName = originalParameterName; if (parameterGroupMap.TryFindParameter(parameterName, out existingParameter)) { if ((existingParameter != null) && !IsValidParameterType(existingParameter, dataType)) { existingParameter = null; } } if (existingParameter == null) { int parameterNameCount = 2; while (createdParameters.Contains(parameterName)) { parameterName = originalParameterName + " " + parameterNameCount; parameterNameCount++; } if (parameterNameCount > 2) { Importer.TheLog.LogWarning(Id, "Renamed parameter: " + originalParameterName + " to: " + parameterName, false); } bool created = false; switch (dataType) { case IFCDataPrimitiveType.String: case IFCDataPrimitiveType.Enumeration: case IFCDataPrimitiveType.Binary: created = IFCPropertySet.AddParameterString(doc, element, category, objDef, parameterName, stringValueToUse, Id); break; case IFCDataPrimitiveType.Integer: created = IFCPropertySet.AddParameterInt(doc, element, category, objDef, parameterName, intValueToUse.Value, Id); break; case IFCDataPrimitiveType.Boolean: created = IFCPropertySet.AddParameterBoolean(doc, element, category, objDef, parameterName, boolValueToUse.Value, Id); break; case IFCDataPrimitiveType.Logical: if (logicalValueToUse != IFCLogical.Unknown) { created = IFCPropertySet.AddParameterBoolean(doc, element, category, objDef, parameterName, (logicalValueToUse == IFCLogical.True), Id); } break; case IFCDataPrimitiveType.Double: created = IFCPropertySet.AddParameterDouble(doc, element, category, objDef, parameterName, specTypeId, unitsTypeId, doubleValueToUse.Value, Id); break; case IFCDataPrimitiveType.Instance: created = IFCPropertySet.AddParameterElementId(doc, element, category, objDef, parameterName, elementIdValueToUse, Id); break; } if (created) { createdParameters.Add(originalParameterName); } return; } bool couldSetValue = false; switch (existingParameter.StorageType) { case StorageType.String: { switch (dataType) { case IFCDataPrimitiveType.String: case IFCDataPrimitiveType.Enumeration: case IFCDataPrimitiveType.Binary: couldSetValue = existingParameter.Set(stringValueToUse); break; case IFCDataPrimitiveType.Integer: couldSetValue = existingParameter.Set(intValueToUse.Value.ToString()); break; case IFCDataPrimitiveType.Boolean: couldSetValue = existingParameter.Set(boolValueToUse.Value ? "True" : "False"); break; case IFCDataPrimitiveType.Logical: couldSetValue = existingParameter.Set(logicalValueToUse.ToString()); break; case IFCDataPrimitiveType.Double: couldSetValue = existingParameter.Set(doubleValueToUse.ToString()); break; default: break; } } break; case StorageType.Integer: if (dataType == IFCDataPrimitiveType.Integer) { couldSetValue = existingParameter.Set(intValueToUse.Value); } else if (dataType == IFCDataPrimitiveType.Boolean) { couldSetValue = existingParameter.Set(boolValueToUse.Value ? 1 : 0); } else if (dataType == IFCDataPrimitiveType.Logical) { couldSetValue = (logicalValueToUse == IFCLogical.Unknown) ? true : existingParameter.Set((logicalValueToUse == IFCLogical.True) ? 1 : 0); } break; case StorageType.Double: if (dataType == IFCDataPrimitiveType.Double) { couldSetValue = existingParameter.Set(doubleValueToUse.Value); } else if (dataType == IFCDataPrimitiveType.Integer) { couldSetValue = existingParameter.Set(intValueToUse.Value); } else if (dataType == IFCDataPrimitiveType.Boolean) { couldSetValue = existingParameter.Set(boolValueToUse.Value ? 1 : 0); } else if ((dataType == IFCDataPrimitiveType.Logical) && (logicalValueToUse != IFCLogical.Unknown)) { couldSetValue = existingParameter.Set((logicalValueToUse == IFCLogical.True) ? 1 : 0); } break; } if (!couldSetValue) { Importer.TheLog.LogError(Id, "Couldn't create parameter: " + Name + " of storage type: " + existingParameter.StorageType.ToString(), false); } }
/// <summary> /// Create a label property. /// </summary> /// <param name="file">The IFC file.</param> /// <param name="propertyName">The name of the property.</param> /// <param name="value">The value of the property.</param> /// <param name="valueType">The value type of the property.</param> /// <returns>The created property handle.</returns> public static IFCAnyHandle CreateElectricalVoltageMeasureProperty(IFCFile file, string propertyName, double value, PropertyValueType valueType) { IFCData electricalVoltageData = IFCDataUtil.CreateAsElectricalVoltageMeasure(value); return(CreateCommonProperty(file, propertyName, electricalVoltageData, valueType, null)); }
/// <summary> /// Creates IfcPresentationStyleAssignment for text element type. /// </summary> /// <param name="exporterIFC"> /// The ExporterIFC object. /// </param> /// <param name="textElemType"> /// The text note element type. /// </param> /// <param name="cache"> /// The cache of IfcPresentationStyleAssignment. /// </param> static void CreatePresentationStyleAssignmentForTextElementType(ExporterIFC exporterIFC, TextElementType textElemType, PresentationStyleAssignmentCache cache) { IFCFile file = exporterIFC.GetFile(); Parameter fontNameParam = textElemType.get_Parameter(BuiltInParameter.TEXT_FONT); string fontName = (fontNameParam != null && fontNameParam.StorageType == StorageType.String) ? fontNameParam.AsString() : null; Parameter fontSizeParam = textElemType.get_Parameter(BuiltInParameter.TEXT_SIZE); double fontSize = (fontSizeParam != null && fontSizeParam.StorageType == StorageType.Double) ? fontSizeParam.AsDouble() : -1.0; double scale = exporterIFC.LinearScale; double viewScale = 100.0; // currently hardwired. fontSize *= (scale * viewScale); string ifcPreDefinedItemName = "Text Font"; IList <string> fontNameList = new List <string>(); fontNameList.Add(fontName); IFCAnyHandle textSyleFontModelHnd = IFCInstanceExporter.CreateTextStyleFontModel(file, ifcPreDefinedItemName, fontNameList, null, null, null, IFCDataUtil.CreateAsPositiveLengthMeasure(fontSize)); Parameter fontColorParam = textElemType.get_Parameter(BuiltInParameter.LINE_COLOR); int color = (fontColorParam != null && fontColorParam.StorageType == StorageType.Integer) ? fontColorParam.AsInteger() : 0; double blueVal = ((double)((color & 0xff0000) >> 16)) / 255.0; double greenVal = ((double)((color & 0xff00) >> 8)) / 255.0; double redVal = ((double)(color & 0xff)) / 255.0; IFCAnyHandle colorHnd = IFCInstanceExporter.CreateColourRgb(file, null, redVal, greenVal, blueVal); IFCAnyHandle fontColorHnd = IFCInstanceExporter.CreateTextStyleForDefinedFont(file, colorHnd, null); string ifcAttrName = textElemType.Name; IFCAnyHandle textStyleHnd = IFCInstanceExporter.CreateTextStyle(file, textElemType.Name, fontColorHnd, null, textSyleFontModelHnd); if (IFCAnyHandleUtil.IsNullOrHasNoValue(textStyleHnd)) { return; } HashSet <IFCAnyHandle> presStyleSet = new HashSet <IFCAnyHandle>(); presStyleSet.Add(textStyleHnd); IFCAnyHandle presStyleHnd = IFCInstanceExporter.CreatePresentationStyleAssignment(file, presStyleSet); if (IFCAnyHandleUtil.IsNullOrHasNoValue(presStyleHnd)) { return; } cache.Register(textElemType.Id, presStyleHnd); }
/// <summary>Create a FrequencyMeasure property.</summary> /// <param name="file">The IFC file.</param> /// <param name="propertyName">The name of the property.</param> /// <param name="value">The value of the property.</param> /// <param name="valueType">The value type of the property.</param> /// <returns>The created property handle.</returns> public static IFCAnyHandle CreateFrequencyProperty(IFCFile file, string propertyName, double value, PropertyValueType valueType) { IFCData frequencyData = IFCDataUtil.CreateAsFrequencyMeasure(value); return(CreateCommonProperty(file, propertyName, frequencyData, valueType, null)); }
/// <summary> /// Create a quantity for a given element. /// </summary> /// <param name="doc">The document.</param> /// <param name="element">The element being created.</param> /// <param name="category">The element's category.</param> /// <param name="parameterMap">The parameters of the element. Cached for performance.</param> /// <param name="propertySetName">The name of the containing property set.</param> /// <param name="createdParameters">The names of the created parameters.</param> public override void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap, string propertySetName, ISet <string> createdParameters) { double baseValue = 0.0; IFCDataPrimitiveType type = Value.PrimitiveType; switch (type) { case IFCDataPrimitiveType.Double: baseValue = Value.AsDouble(); break; case IFCDataPrimitiveType.Integer: // This case isn't valid, but could happen when repairing a file Importer.TheLog.LogWarning(Id, "Unexpected integer parameter type, repairing.", false); baseValue = Value.AsInteger(); break; default: Importer.TheLog.LogError(Id, "Invalid parameter type: " + type.ToString() + " for IfcPhysicalSimpleQuantity", false); return; } double doubleValueToUse = Importer.TheProcessor.ScaleValues ? IFCUnit?.Convert(baseValue) ?? baseValue : baseValue; Parameter existingParameter = null; string originalParameterName = propertySetName + "." + Name; string parameterName = originalParameterName; if (!parameterGroupMap.TryFindParameter(parameterName, out existingParameter)) { int parameterNameCount = 2; while (createdParameters.Contains(parameterName)) { parameterName = originalParameterName + " " + parameterNameCount; parameterNameCount++; } if (parameterNameCount > 2) { Importer.TheLog.LogWarning(Id, "Renamed parameter: " + originalParameterName + " to: " + parameterName, false); } if (existingParameter == null) { ForgeTypeId specTypeId; ForgeTypeId unitsTypeId = null; if (IFCUnit != null) { specTypeId = IFCUnit.Spec; unitsTypeId = IFCUnit.Unit; } else { specTypeId = IFCDataUtil.GetUnitTypeFromData(Value, SpecTypeId.Number); } bool created = IFCPropertySet.AddParameterDouble(doc, element, category, objDef, parameterName, specTypeId, unitsTypeId, doubleValueToUse, Id); if (created) { createdParameters.Add(parameterName); } return; } } bool setValue = true; switch (existingParameter.StorageType) { case StorageType.String: existingParameter.Set(doubleValueToUse.ToString()); break; case StorageType.Double: existingParameter.Set(doubleValueToUse); break; default: setValue = false; break; } if (!setValue) { Importer.TheLog.LogError(Id, "Couldn't create parameter: " + Name + " of storage type: " + existingParameter.StorageType.ToString(), false); } }