xBIM 基础05 3D墙案例

系列目录【已更新最新开发文章，点击查看详细】

　　使用编码的形式去生成一堵墙的模型需要做很多的工作。

 using System;

 using System.Collections.Generic;

 using System.Diagnostics;

 using System.Linq;

 using Xbim.Common;

 using Xbim.Common.Step21;

 using Xbim.Ifc;

 using Xbim.IO;

 using Xbim.Ifc4.ActorResource;

 using Xbim.Ifc4.DateTimeResource;

 using Xbim.Ifc4.ExternalReferenceResource;

 using Xbim.Ifc4.PresentationOrganizationResource;

 using Xbim.Ifc4.GeometricConstraintResource;

 using Xbim.Ifc4.GeometricModelResource;

 using Xbim.Ifc4.GeometryResource;

 using Xbim.Ifc4.Interfaces;

 using Xbim.Ifc4.Kernel;

 using Xbim.Ifc4.MaterialResource;

 using Xbim.Ifc4.MeasureResource;

 using Xbim.Ifc4.ProductExtension;

 using Xbim.Ifc4.ProfileResource;

 using Xbim.Ifc4.PropertyResource;

 using Xbim.Ifc4.QuantityResource;

 using Xbim.Ifc4.RepresentationResource;

 using Xbim.Ifc4.SharedBldgElements;

 namespace HelloWall

 {

     class Program

     {

         /// <summary>

         ///  此示例演示了创建包含单个标准事例墙的符合IFC模型的最小步骤。

         /// </summary>

         static int Main()

         {

             // 首先创建并初始化一个名为hello wall的模型

             Console.WriteLine("Initialising the IFC Project 初始化 IFc 项目....");

             using (var model = CreateandInitModel("HelloWall"))

             {

                 if (model != null)

                 {

                     IfcBuilding building = CreateBuilding(model, "Default Building 默认建筑");

                     IfcBuildingStorey storey = CreateStorey(building);

                     IfcWallStandardCase wall = CreateWall(model, , , );

                     if(wall != null)

                     {

                         AddPropertiesToWall(model, wall);

                     }

                     using (var txn = model.BeginTransaction("Add Wall 添加墙"))

                     {

                         building.AddToSpatialDecomposition(storey);

                         storey.AddElement(wall);

                         txn.Commit();

                     }

                     if (wall != null)

                     {

                         try

                         {

                             Console.WriteLine("Standard Wall successfully created....");

                             model.SaveAs("HelloWallIfc4.ifc", StorageType.Ifc); // 保存到文件中

                             Console.WriteLine("HelloWallIfc4.ifc has been successfully written");

                         }

                         catch (Exception e)

                         {

                             Console.WriteLine("Failed to save HelloWall.ifc");

                             Console.WriteLine(e.Message);

                         }

                     }

                 }

                 else

                 {

                     Console.WriteLine("Failed to initialise the model");

                 }

             }

             Console.WriteLine("Press any key to exit to view the IFC file....");

             Console.ReadKey();

             LaunchNotepad("HelloWallIfc4.ifc");

             return ;

         }

         private static IfcBuildingStorey CreateStorey(IfcBuilding building)

         {

             var model = building.Model;

             IfcBuildingStorey storey;

             using (var txn = model.BeginTransaction("Storey creation"))

             {

                 storey = model.Instances.New<IfcBuildingStorey>(s =>

                 {

                     s.Name = "Default storey";

                     s.Elevation = 0.0;

                 });

                 txn.Commit();

             }

             return storey;

         }

         /// <summary>

         ///  在记事本中打开指定的文件

         /// </summary>

         /// <param name="fileName"></param>

         private static void LaunchNotepad(string fileName)

         {

             try

             {

                 var p = new Process { StartInfo = { FileName = fileName, CreateNoWindow = false } };

                 p.Start();

             }

             catch (Exception ex)

             {

                 Console.WriteLine("Exception Occurred :{0},{1}", ex.Message, ex.StackTrace);

             }

         }

         /// <summary>

         ///  创建建筑对象

         /// </summary>

         /// <param name="model"></param>

         /// <param name="name">建筑名称</param>

         /// <returns></returns>

         private static IfcBuilding CreateBuilding(IfcStore model, string name)

         {

             using (var txn = model.BeginTransaction("Create Building 创建建筑对象"))

             {

                 var building = model.Instances.New<IfcBuilding>();

                 building.Name = name;

                 building.CompositionType = IfcElementCompositionEnum.ELEMENT; // 组成类型

                 var localPlacement = model.Instances.New<IfcLocalPlacement>();

                 building.ObjectPlacement = localPlacement;

                 var placement = model.Instances.New<IfcAxis2Placement3D>();

                 localPlacement.RelativePlacement = placement;

                 placement.Location = model.Instances.New<IfcCartesianPoint>(p => p.SetXYZ(, , ));

                 // 获取第一个或者默认的项目

                 var project = model.Instances.OfType<IfcProject>().FirstOrDefault();

                 if(project != null)

                 {

                     project.AddBuilding(building);

                 }

                 txn.Commit();

                 return building;

             }

         }

         /// <summary>

         ///  设置任何模型必须提供的基本参数、单位、所有权等

         /// </summary>

         /// <param name="projectName">项目名称</param>

         /// <returns></returns>

         private static IfcStore CreateandInitModel(string projectName)

         {

             // 首先，我们需要为新模型中的数据所有权设置一些凭证

             var credentials = new XbimEditorCredentials

             {

                 ApplicationDevelopersName = "xBimTeam",

                 ApplicationFullName = "Hello Wall Application",

                 ApplicationIdentifier = "HelloWall.exe",

                 ApplicationVersion = "1.0",

                 EditorsFamilyName = "Team",

                 EditorsGivenName = "xBIM",

                 EditorsOrganisationName = "xBimTeam"

             };

             // 现在我们可以创建一个ifcstore，它是ifc4格式的，将保存在内存中而不是数据库中。

             // 如果模型的容量大于50MB，或者需要健壮的事务，那么数据库在性能方面通常更好。

             var model = IfcStore.Create(credentials, XbimSchemaVersion.Ifc4, XbimStoreType.InMemoryModel);

             // 开始事务，因为对模型的所有更改都是ACID

             using (var txn = model.BeginTransaction("Initialise Model 初始化模型"))

             {

                 var project = model.Instances.New<IfcProject>(); // 创建一个项目

                 project.Initialize(ProjectUnits.SIUnitsUK); // 将单位设置为si（mm和米）

                 project.Name = projectName;

                 txn.Commit(); // 现在提交更改，否则它们将在using语句的范围结束时回滚。

             }

             return model;

         }

         /// <summary>

         ///  创建一个墙和它的几何图形，许多几何图形表示是可能的，并选择挤压矩形示意图，因为这通常用于标准情况下的墙。

         /// </summary>

         /// <param name="model"></param>

         /// <param name="length">矩形足迹的长度</param>

         /// <param name="width">矩形足迹的宽度（墙的宽度）</param>

         /// <param name="height">挤出墙的高度，挤出是垂直的</param>

         /// <returns></returns>

         static private IfcWallStandardCase CreateWall(IfcStore model, double length, double width, double height)

         {

             using (var txn = model.BeginTransaction("Create Wall 创建墙"))

             {

                 var wall = model.Instances.New<IfcWallStandardCase>(); //IfcWallStandardCase：IFC墙标准案例

                 wall.Name = "A Standard rectangular wall 标准矩形墙";

                 // 将墙表示为矩形轮廓，墙的矩形剖面

                 var rectProf = model.Instances.New<IfcRectangleProfileDef>(); //IfcRectangleProfileDef：IFC矩形轮廓定义

                 rectProf.ProfileType = IfcProfileTypeEnum.AREA;

                 rectProf.XDim = width;

                 rectProf.YDim = length;

                 var insertPoint = model.Instances.New<IfcCartesianPoint>(); //IfcCartesianPoint：IFc 笛卡尔点

                 insertPoint.SetXY(, ); //在任意位置插入

                 rectProf.Position = model.Instances.New<IfcAxis2Placement2D>();

                 rectProf.Position.Location = insertPoint;

                 // 模型区域实心

                 var body = model.Instances.New<IfcExtrudedAreaSolid>(); //IfcExtrudedAreaSolid：IFC拉伸区域实体

                 body.Depth = height;

                 body.SweptArea = rectProf;

                 body.ExtrudedDirection = model.Instances.New<IfcDirection>();//IfcDirection：IFC方向

                 body.ExtrudedDirection.SetXYZ(, , );

                 // 在模型中插入几何参数

                 var origin = model.Instances.New<IfcCartesianPoint>(); //IfcCartesianPoint：IFc 笛卡尔点

                 origin.SetXYZ(, , );

                 body.Position = model.Instances.New<IfcAxis2Placement3D>();

                 body.Position.Location = origin;

                 // 创建定义形状以保存几何图形

                 var shape = model.Instances.New<IfcShapeRepresentation>();//IfcShapeRepresentation：IFC形状表示

                 var modelContext = model.Instances.OfType<IfcGeometricRepresentationContext>().FirstOrDefault(); //IfcGeometricRepresentationContext：IFC几何表示上下文

                 shape.ContextOfItems = modelContext;

                 shape.RepresentationType = "SweptSolid";

                 shape.RepresentationIdentifier = "Body";

                 shape.Items.Add(body);

                 // 创建产品定义并将模型几何图形添加到墙中

                 var rep = model.Instances.New<IfcProductDefinitionShape>(); //IfcProductDefinitionShape：IFC产品定义形状

                 rep.Representations.Add(shape);

                 wall.Representation = rep;

                 // 现在将墙放置到模型中

                 var lp = model.Instances.New<IfcLocalPlacement>();

                 var ax3D = model.Instances.New<IfcAxis2Placement3D>();

                 ax3D.Location = origin;

                 ax3D.RefDirection = model.Instances.New<IfcDirection>();

                 ax3D.RefDirection.SetXYZ(, , );

                 ax3D.Axis = model.Instances.New<IfcDirection>();

                 ax3D.Axis.SetXYZ(, , );

                 lp.RelativePlacement = ax3D;

                 wall.ObjectPlacement = lp;

                 // Where Clause: ifcwallstandardard 依赖于 ifcmmateriallayersetusage 的规定。

                 var ifcMaterialLayerSetUsage = model.Instances.New<IfcMaterialLayerSetUsage>();

                 var ifcMaterialLayerSet = model.Instances.New<IfcMaterialLayerSet>();

                 var ifcMaterialLayer = model.Instances.New<IfcMaterialLayer>();

                 ifcMaterialLayer.LayerThickness = ;

                 ifcMaterialLayerSet.MaterialLayers.Add(ifcMaterialLayer);

                 ifcMaterialLayerSetUsage.ForLayerSet = ifcMaterialLayerSet;

                 ifcMaterialLayerSetUsage.LayerSetDirection = IfcLayerSetDirectionEnum.AXIS2;

                 ifcMaterialLayerSetUsage.DirectionSense = IfcDirectionSenseEnum.NEGATIVE;

                 ifcMaterialLayerSetUsage.OffsetFromReferenceLine = ;

                 // 将材料添加到墙商

                 var material = model.Instances.New<IfcMaterial>();

                 material.Name = "some material";

                 var ifcRelAssociatesMaterial = model.Instances.New<IfcRelAssociatesMaterial>();

                 ifcRelAssociatesMaterial.RelatingMaterial = material;

                 ifcRelAssociatesMaterial.RelatedObjects.Add(wall);

                 ifcRelAssociatesMaterial.RelatingMaterial = ifcMaterialLayerSetUsage;

                 // ifcPresentationLayerAssignment 对于 ifcwall 或 ifcwallstandardcase 中的 CAD 演示是必须的

                 var ifcPresentationLayerAssignment = model.Instances.New<IfcPresentationLayerAssignment>();

                 ifcPresentationLayerAssignment.Name = "some ifcPresentationLayerAssignment";

                 ifcPresentationLayerAssignment.AssignedItems.Add(shape);

                 // 如果 IfcPolyline 具有两个点，则对于 IfcWall 是必需的

                 var ifcPolyline = model.Instances.New<IfcPolyline>();

                 var startPoint = model.Instances.New<IfcCartesianPoint>();

                 startPoint.SetXY(, );

                 var endPoint = model.Instances.New<IfcCartesianPoint>();

                 endPoint.SetXY(, );

                 ifcPolyline.Points.Add(startPoint);

                 ifcPolyline.Points.Add(endPoint);

                 var shape2D = model.Instances.New<IfcShapeRepresentation>();

                 shape2D.ContextOfItems = modelContext;

                 shape2D.RepresentationIdentifier = "Axis";

                 shape2D.RepresentationType = "Curve2D";

                 shape2D.Items.Add(ifcPolyline);

                 rep.Representations.Add(shape2D);

                 txn.Commit();

                 return wall;

             }

         }

         /// <summary>

         ///  向墙添加一些属性,

         /// </summary>

         /// <param name="model">XbimModel</param>

         /// <param name="wall"></param>

         static private void AddPropertiesToWall(IfcStore model, IfcWallStandardCase wall)

         {

             using (var txn = model.BeginTransaction("Create Wall"))

             {

                 CreateElementQuantity(model, wall);

                 CreateSimpleProperty(model, wall);

                 txn.Commit();

             }

         }

         private static void CreateSimpleProperty(IfcStore model, IfcWallStandardCase wall)

         {

             var ifcPropertySingleValue = model.Instances.New<IfcPropertySingleValue>(psv =>

             {

                 psv.Name = "IfcPropertySingleValue:Time";

                 psv.Description = "";

                 psv.NominalValue = new IfcTimeMeasure(150.0);

                 psv.Unit = model.Instances.New<IfcSIUnit>(siu =>

                 {

                     siu.UnitType = IfcUnitEnum.TIMEUNIT;

                     siu.Name = IfcSIUnitName.SECOND;

                 });

             });

             var ifcPropertyEnumeratedValue = model.Instances.New<IfcPropertyEnumeratedValue>(pev =>

             {

                 pev.Name = "IfcPropertyEnumeratedValue:Music";

                 pev.EnumerationReference = model.Instances.New<IfcPropertyEnumeration>(pe =>

                     {

                         pe.Name = "Notes";

                         pe.EnumerationValues.Add(new IfcLabel("Do"));

                         pe.EnumerationValues.Add(new IfcLabel("Re"));

                         pe.EnumerationValues.Add(new IfcLabel("Mi"));

                         pe.EnumerationValues.Add(new IfcLabel("Fa"));

                         pe.EnumerationValues.Add(new IfcLabel("So"));

                         pe.EnumerationValues.Add(new IfcLabel("La"));

                         pe.EnumerationValues.Add(new IfcLabel("Ti"));

                     });

                 pev.EnumerationValues.Add(new IfcLabel("Do"));

                 pev.EnumerationValues.Add(new IfcLabel("Re"));

                 pev.EnumerationValues.Add(new IfcLabel("Mi"));

             });

             var ifcPropertyBoundedValue = model.Instances.New<IfcPropertyBoundedValue>(pbv =>

             {

                 pbv.Name = "IfcPropertyBoundedValue:Mass";

                 pbv.Description = "";

                 pbv.UpperBoundValue = new IfcMassMeasure(5000.0);

                 pbv.LowerBoundValue = new IfcMassMeasure(1000.0);

                 pbv.Unit = model.Instances.New<IfcSIUnit>(siu =>

                 {

                     siu.UnitType = IfcUnitEnum.MASSUNIT;

                     siu.Name = IfcSIUnitName.GRAM;

                     siu.Prefix = IfcSIPrefix.KILO;

                 });

             });

             var definingValues = new List<IfcReal> { new IfcReal(100.0), new IfcReal(200.0), new IfcReal(400.0), 
                                                         new IfcReal(800.0), new IfcReal(1600.0), new IfcReal(3200.0), };

             var definedValues = new List<IfcReal> { new IfcReal(20.0), new IfcReal(42.0), new IfcReal(46.0), 
                                                        new IfcReal(56.0), new IfcReal(60.0), new IfcReal(65.0), };

             var ifcPropertyTableValue = model.Instances.New<IfcPropertyTableValue>(ptv =>

             {

                 ptv.Name = "IfcPropertyTableValue:Sound";

                 foreach (var item in definingValues)

                 {

                     ptv.DefiningValues.Add(item);

                 }

                 foreach (var item in definedValues)

                 {

                     ptv.DefinedValues.Add(item);

                 }

                 ptv.DefinedUnit = model.Instances.New<IfcContextDependentUnit>(cd =>

                 {

                     cd.Dimensions = model.Instances.New<IfcDimensionalExponents>(de =>

                     {

                         de.LengthExponent = ;

                         de.MassExponent = ;

                         de.TimeExponent = ;

                         de.ElectricCurrentExponent = ;

                         de.ThermodynamicTemperatureExponent = ;

                         de.AmountOfSubstanceExponent = ;

                         de.LuminousIntensityExponent = ;

                     });

                     cd.UnitType = IfcUnitEnum.FREQUENCYUNIT;

                     cd.Name = "dB";

                 });

             });

             var listValues = new List<IfcLabel> { new IfcLabel("Red"), 
                                                      new IfcLabel("Green"), 
                                                      new IfcLabel("Blue"), 
                                                      new IfcLabel("Pink"), 
                                                      new IfcLabel("White"), 
                                                      new IfcLabel("Black"), };

             var ifcPropertyListValue = model.Instances.New<IfcPropertyListValue>(plv =>

             {

                 plv.Name = "IfcPropertyListValue:Colours";

                 foreach (var item in listValues)

                 {

                     plv.ListValues.Add(item);

                 }

             });

             var ifcMaterial = model.Instances.New<IfcMaterial>(m =>

             {

                 m.Name = "Brick";

             });

             var ifcPrValueMaterial = model.Instances.New<IfcPropertyReferenceValue>(prv =>

             {

                 prv.Name = "IfcPropertyReferenceValue:Material";

                 prv.PropertyReference = ifcMaterial;

             });

             var ifcMaterialList = model.Instances.New<IfcMaterialList>(ml =>

                 {

                     ml.Materials.Add(ifcMaterial);

                     ml.Materials.Add(model.Instances.New<IfcMaterial>(m => { m.Name = "Cavity"; }));

                     ml.Materials.Add(model.Instances.New<IfcMaterial>(m => { m.Name = "Block"; }));

                 });

             var ifcMaterialLayer = model.Instances.New<IfcMaterialLayer>(ml =>

             {

                 ml.Material = ifcMaterial;

                 ml.LayerThickness = 100.0;

             });

             var ifcPrValueMatLayer = model.Instances.New<IfcPropertyReferenceValue>(prv =>

             {

                 prv.Name = "IfcPropertyReferenceValue:MaterialLayer";

                 prv.PropertyReference = ifcMaterialLayer;

             });

             var ifcDocumentReference = model.Instances.New<IfcDocumentReference>(dr =>

             {

                 dr.Name = "Document";

                 dr.Location = "c://Documents//TheDoc.Txt";

             });

             var ifcPrValueRef = model.Instances.New<IfcPropertyReferenceValue>(prv =>

             {

                 prv.Name = "IfcPropertyReferenceValue:Document";

                 prv.PropertyReference = ifcDocumentReference;

             });

             var ifcTimeSeries = model.Instances.New<IfcRegularTimeSeries>(ts =>

             {

                 ts.Name = "Regular Time Series";

                 ts.Description = "Time series of events";

                 ts.StartTime = new IfcDateTime("2015-02-14T12:01:01");

                 ts.EndTime = new IfcDateTime("2015-05-15T12:01:01");

                 ts.TimeSeriesDataType = IfcTimeSeriesDataTypeEnum.CONTINUOUS;

                 ts.DataOrigin = IfcDataOriginEnum.MEASURED;

                 ts.TimeStep = ; //7 days in secs

             });

             var ifcPrValueTimeSeries = model.Instances.New<IfcPropertyReferenceValue>(prv =>

             {

                 prv.Name = "IfcPropertyReferenceValue:TimeSeries";

                 prv.PropertyReference = ifcTimeSeries;

             });

             var ifcAddress = model.Instances.New<IfcPostalAddress>(a =>

             {

                 a.InternalLocation = "Room 101";

                 a.AddressLines.AddRange(new[] { new IfcLabel("12 New road"), new IfcLabel("DoxField") });

                 a.Town = "Sunderland";

                 a.PostalCode = "DL01 6SX";

             });

             var ifcPrValueAddress = model.Instances.New<IfcPropertyReferenceValue>(prv =>

             {

                 prv.Name = "IfcPropertyReferenceValue:Address";

                 prv.PropertyReference = ifcAddress;

             });

             var ifcTelecomAddress = model.Instances.New<IfcTelecomAddress>(a =>

             {

                 a.TelephoneNumbers.Add(new IfcLabel("01325 6589965"));

                 a.ElectronicMailAddresses.Add(new IfcLabel("bob@bobsworks.com"));

             });

             var ifcPrValueTelecom = model.Instances.New<IfcPropertyReferenceValue>(prv =>

             {

                 prv.Name = "IfcPropertyReferenceValue:Telecom";

                 prv.PropertyReference = ifcTelecomAddress;

             });

             // ifcelementQuantity 创建模型元素数量

             var ifcPropertySet = model.Instances.New<IfcPropertySet>(ps =>

             {

                 ps.Name = "Test:IfcPropertySet";

                 ps.Description = "Property Set";

                 ps.HasProperties.Add(ifcPropertySingleValue);

                 ps.HasProperties.Add(ifcPropertyEnumeratedValue);

                 ps.HasProperties.Add(ifcPropertyBoundedValue);

                 ps.HasProperties.Add(ifcPropertyTableValue);

                 ps.HasProperties.Add(ifcPropertyListValue);

                 ps.HasProperties.Add(ifcPrValueMaterial);

                 ps.HasProperties.Add(ifcPrValueMatLayer);

                 ps.HasProperties.Add(ifcPrValueRef);

                 ps.HasProperties.Add(ifcPrValueTimeSeries);

                 ps.HasProperties.Add(ifcPrValueAddress);

                 ps.HasProperties.Add(ifcPrValueTelecom);

             });

             // 需要建立关系

             model.Instances.New<IfcRelDefinesByProperties>(rdbp =>

             {

                 rdbp.Name = "Property Association";

                 rdbp.Description = "IfcPropertySet associated to wall";

                 rdbp.RelatedObjects.Add(wall);

                 rdbp.RelatingPropertyDefinition = ifcPropertySet;

             });

         }

         private static void CreateElementQuantity(IfcStore model, IfcWallStandardCase wall)

         {

             // 创建模型元素数量

             // 首先我们需模型简单物理量，首先将使用模型量长度

             var ifcQuantityArea = model.Instances.New<IfcQuantityLength>(qa =>

             {

                 qa.Name = "IfcQuantityArea:Area";

                 qa.Description = "";

                 qa.Unit = model.Instances.New<IfcSIUnit>(siu =>

                 {

                     siu.UnitType = IfcUnitEnum.LENGTHUNIT;

                     siu.Prefix = IfcSIPrefix.MILLI;

                     siu.Name = IfcSIUnitName.METRE;

                 });

                 qa.LengthValue = 100.0;

             });

             // 然后，上下文相关单元的数量计数

             var ifcContextDependentUnit = model.Instances.New<IfcContextDependentUnit>(cd =>

                 {

                     cd.Dimensions = model.Instances.New<IfcDimensionalExponents>(de =>

                         {

                             de.LengthExponent = ;

                             de.MassExponent = ;

                             de.TimeExponent = ;

                             de.ElectricCurrentExponent = ;

                             de.ThermodynamicTemperatureExponent = ;

                             de.AmountOfSubstanceExponent = ;

                             de.LuminousIntensityExponent = ;

                         });

                     cd.UnitType = IfcUnitEnum.LENGTHUNIT;

                     cd.Name = "Elephants";

                 });

             var ifcQuantityCount = model.Instances.New<IfcQuantityCount>(qc =>

             {

                 qc.Name = "IfcQuantityCount:Elephant";

                 qc.CountValue = ;

                 qc.Unit = ifcContextDependentUnit;

             });

             // 使用转换单位

             var ifcConversionBasedUnit = model.Instances.New<IfcConversionBasedUnit>(cbu =>

             {

                 cbu.ConversionFactor = model.Instances.New<IfcMeasureWithUnit>(mu =>

                 {

                     mu.ValueComponent = new IfcRatioMeasure(25.4);

                     mu.UnitComponent = model.Instances.New<IfcSIUnit>(siu =>

                     {

                         siu.UnitType = IfcUnitEnum.LENGTHUNIT;

                         siu.Prefix = IfcSIPrefix.MILLI;

                         siu.Name = IfcSIUnitName.METRE;

                     });

                 });

                 cbu.Dimensions = model.Instances.New<IfcDimensionalExponents>(de =>

                 {

                     de.LengthExponent = ;

                     de.MassExponent = ;

                     de.TimeExponent = ;

                     de.ElectricCurrentExponent = ;

                     de.ThermodynamicTemperatureExponent = ;

                     de.AmountOfSubstanceExponent = ;

                     de.LuminousIntensityExponent = ;

                 });

                 cbu.UnitType = IfcUnitEnum.LENGTHUNIT;

                 cbu.Name = "Inch";

             });

             var ifcQuantityLength = model.Instances.New<IfcQuantityLength>(qa =>

             {

                 qa.Name = "IfcQuantityLength:Length";

                 qa.Description = "";

                 qa.Unit = ifcConversionBasedUnit;

                 qa.LengthValue = 24.0;

             });

             // 创建 IfcElementQuantity

             var ifcElementQuantity = model.Instances.New<IfcElementQuantity>(eq =>

             {

                 eq.Name = "Test:IfcElementQuantity";

                 eq.Description = "Measurement quantity";

                 eq.Quantities.Add(ifcQuantityArea);

                 eq.Quantities.Add(ifcQuantityCount);

                 eq.Quantities.Add(ifcQuantityLength);

             });

             // 创建关系

             model.Instances.New<IfcRelDefinesByProperties>(rdbp =>

             {

                 rdbp.Name = "Area Association";

                 rdbp.Description = "IfcElementQuantity associated to wall";

                 rdbp.RelatedObjects.Add(wall);

                 rdbp.RelatingPropertyDefinition = ifcElementQuantity;

             });

         }

     }

 }

生成的IFC文件可以在您选择的查看器中打开：

ISO--;

HEADER;

FILE_DESCRIPTION ((''), '2;1');

FILE_NAME ('', '2016-10-31T10:18:08', (''), (''), 'Xbim File Processor version 4.0.0.0', 'Xbim version 4.0.0.0', '');

FILE_SCHEMA (('IFC4'));

ENDSEC;

DATA;

#=IFCPROJECT('2MSHGQD897wuyjYHKVxtyf',#,'HelloWall',$,$,$,$,(#,#),#);

#=IFCOWNERHISTORY(#,#,$,.ADDED.,$,$,$,);

#=IFCPERSON($,'Team','xBIM',$,$,$,$,$);

#=IFCORGANIZATION($,'xBimTeam',$,$,$);

#=IFCPERSONANDORGANIZATION(#,#,$);

#=IFCORGANIZATION($,'xBimTeam',$,$,$);

#=IFCAPPLICATION(#,'1.0','Hello Wall Application','HelloWall.exe');

#=IFCUNITASSIGNMENT((#,#,#,#,#,#,#,#,#));

#=IFCSIUNIT(*,.LENGTHUNIT.,.MILLI.,.METRE.);

#=IFCSIUNIT(*,.AREAUNIT.,$,.SQUARE_METRE.);

#=IFCSIUNIT(*,.VOLUMEUNIT.,$,.CUBIC_METRE.);

#=IFCSIUNIT(*,.SOLIDANGLEUNIT.,$,.STERADIAN.);

#=IFCSIUNIT(*,.PLANEANGLEUNIT.,$,.RADIAN.);

#=IFCSIUNIT(*,.MASSUNIT.,$,.GRAM.);

#=IFCSIUNIT(*,.TIMEUNIT.,$,.SECOND.);

#=IFCSIUNIT(*,.THERMODYNAMICTEMPERATUREUNIT.,$,.DEGREE_CELSIUS.);

#=IFCSIUNIT(*,.LUMINOUSINTENSITYUNIT.,$,.LUMEN.);

#=IFCCARTESIANPOINT((.,.,.));

#=IFCAXIS2PLACEMENT3D(#,$,$);

#=IFCGEOMETRICREPRESENTATIONCONTEXT('Building Model','Model',,.E-,#,$);

#=IFCCARTESIANPOINT((.,.));

#=IFCAXIS2PLACEMENT2D(#,$);

#=IFCGEOMETRICREPRESENTATIONCONTEXT('Building Plan View','Plan',,.E-,#,$);

#=IFCBUILDING('0jQ$yvAIv6URCwLuvWnAo0',#,'Default Building',$,$,#,$,$,.ELEMENT.,$,$,$);

#=IFCLOCALPLACEMENT($,#);

#=IFCAXIS2PLACEMENT3D(#,$,$);

#=IFCCARTESIANPOINT((.,.,.));

#=IFCRELAGGREGATES('3Qs6TKkPjASQ1ctGzUSQ7F',#,$,$,#,(#));

#=IFCWALLSTANDARDCASE('3NBPkknun6EuV9fpeE6rFh',#,'A Standard rectangular wall',$,$,#,#,$,$);

#=IFCRECTANGLEPROFILEDEF(.AREA.,$,#,.,.);

#=IFCCARTESIANPOINT((.,.));

#=IFCAXIS2PLACEMENT2D(#,$);

#=IFCEXTRUDEDAREASOLID(#,#,#,.);

#=IFCDIRECTION((.,.,.));

#=IFCCARTESIANPOINT((.,.,.));

#=IFCAXIS2PLACEMENT3D(#,$,$);

#=IFCSHAPEREPRESENTATION(#,'Body','SweptSolid',(#));

#=IFCPRODUCTDEFINITIONSHAPE($,$,(#,#));

#=IFCLOCALPLACEMENT($,#);

#=IFCAXIS2PLACEMENT3D(#,#,#);

#=IFCDIRECTION((.,.,.));

#=IFCDIRECTION((.,.,.));

#=IFCMATERIALLAYERSETUSAGE(#,.AXIS2.,.NEGATIVE.,.,$);

#=IFCMATERIALLAYERSET((#),$,$);

#=IFCMATERIALLAYER($,.,$,$,$,$,$);

#=IFCMATERIAL('some material',$,$);

#=IFCRELASSOCIATESMATERIAL('0is_vsqtn9ouErH3XVg3O8',#,$,$,(#),#);

#=IFCPRESENTATIONLAYERASSIGNMENT('some ifcPresentationLayerAssignment',$,(#),$);

#=IFCPOLYLINE((#,#));

#=IFCCARTESIANPOINT((.,.));

#=IFCCARTESIANPOINT((.,.));

#=IFCSHAPEREPRESENTATION(#,'Axis','Curve2D',(#));

#=IFCSIUNIT(*,.LENGTHUNIT.,.MILLI.,.METRE.);

#=IFCQUANTITYLENGTH('IfcQuantityArea:Area','',#,.,$);

#=IFCDIMENSIONALEXPONENTS(,,,,,,);

#=IFCCONTEXTDEPENDENTUNIT(#,.LENGTHUNIT.,'Elephants');

#=IFCQUANTITYCOUNT('IfcQuantityCount:Elephant',$,#,.,$);

#=IFCSIUNIT(*,.LENGTHUNIT.,.MILLI.,.METRE.);

#=IFCMEASUREWITHUNIT(IFCRATIOMEASURE(25.4),#);

#=IFCDIMENSIONALEXPONENTS(,,,,,,);

#=IFCCONVERSIONBASEDUNIT(#,.LENGTHUNIT.,'Inch',#);

#=IFCQUANTITYLENGTH('IfcQuantityLength:Length','',#,.,$);

#=IFCELEMENTQUANTITY('2NzDD6BkfDFAUH5zVe3vf0',#,'Test:IfcElementQuantity','Measurement quantity',$,(#,#,#));

#=IFCRELDEFINESBYPROPERTIES('2rxEDLnp59XvLpgGjoNnBQ',#,'Area Association','IfcElementQuantity associated to wall',(#),#);

#=IFCSIUNIT(*,.TIMEUNIT.,$,.SECOND.);

#=IFCPROPERTYSINGLEVALUE('IfcPropertySingleValue:Time','',IFCTIMEMEASURE(.),#);

#=IFCPROPERTYENUMERATION('Notes',(IFCLABEL('Do'),IFCLABEL('Re'),IFCLABEL('Mi'),IFCLABEL('Fa'),IFCLABEL('So'),IFCLABEL('La'),IFCLABEL('Ti')),$);

#=IFCPROPERTYENUMERATEDVALUE('IfcPropertyEnumeratedValue:Music',$,(IFCLABEL('Do'),IFCLABEL('Re'),IFCLABEL('Mi')),#);

#=IFCSIUNIT(*,.MASSUNIT.,.KILO.,.GRAM.);

#=IFCPROPERTYBOUNDEDVALUE('IfcPropertyBoundedValue:Mass','',IFCMASSMEASURE(.),IFCMASSMEASURE(.),#,$);

#=IFCDIMENSIONALEXPONENTS(,,,,,,);

#=IFCCONTEXTDEPENDENTUNIT(#,.FREQUENCYUNIT.,'dB');

#=IFCPROPERTYTABLEVALUE('IfcPropertyTableValue:Sound',$,(IFCREAL(.),IFCREAL(.),IFCREAL(.),IFCREAL(.),IFCREAL(.),IFCREAL(.)),(IFCREAL(.),IFCREAL(.),IFCREAL(.),IFCREAL(.),IFCREAL(.),IFCREAL(.)),$,$,#,$);

#=IFCPROPERTYLISTVALUE('IfcPropertyListValue:Colours',$,(IFCLABEL('Red'),IFCLABEL('Green'),IFCLABEL('Blue'),IFCLABEL('Pink'),IFCLABEL('White'),IFCLABEL('Black')),$);

#=IFCMATERIAL('Brick',$,$);

#=IFCPROPERTYREFERENCEVALUE('IfcPropertyReferenceValue:Material',$,$,#);

#=IFCMATERIAL('Cavity',$,$);

#=IFCMATERIAL('Block',$,$);

#=IFCMATERIALLIST((#,#,#));

#=IFCMATERIALLAYER(#,.,$,$,$,$,$);

#=IFCPROPERTYREFERENCEVALUE('IfcPropertyReferenceValue:MaterialLayer',$,$,#);

#=IFCDOCUMENTREFERENCE('c://Documents//TheDoc.Txt',$,'Document',$,$);

#=IFCPROPERTYREFERENCEVALUE('IfcPropertyReferenceValue:Document',$,$,#);

#=IFCREGULARTIMESERIES('Regular Time Series','Time series of events','2015-02-14T12:01:01','2015-05-15T12:01:01',.CONTINUOUS.,.MEASURED.,$,$,.,());

#=IFCPROPERTYREFERENCEVALUE('IfcPropertyReferenceValue:TimeSeries',$,$,#);

#=IFCPOSTALADDRESS($,$,$,'Room 101',('12 New road','DoxField'),$,'Sunderland',$,'DL01 6SX',$);

#=IFCPROPERTYREFERENCEVALUE('IfcPropertyReferenceValue:Address',$,$,#);

#=IFCTELECOMADDRESS($,$,$,('01325 6589965'),$,$,('bob@bobsworks.com'),$,$);

#=IFCPROPERTYREFERENCEVALUE('IfcPropertyReferenceValue:Telecom',$,$,#);

#=IFCPROPERTYSET('2qJSTdQSj0wQKmIdFVroG2',#,'Test:IfcPropertySet','Property Set',(#,#,#,#,#,#,#,#,#,#,#));

#=IFCRELDEFINESBYPROPERTIES('3n83nuxoj0gA5F$UnucPP3',#,'Property Association','IfcPropertySet associated to wall',(#),#);

#=IFCRELCONTAINEDINSPATIALSTRUCTURE('1mefbELBn5JQeF1AH4vA0$',#,$,$,(#),#);

ENDSEC;

END-ISO--;

系列目录【已更新最新开发文章，点击查看详细】

巴特西

xBIM 基础05 3D墙案例

最新文章

热门文章