xBIM 基础05 3D墙案例
阅读原文时间:2023年07月10日阅读:1

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

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

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
{
///

/// 此示例演示了创建包含单个标准事例墙的符合IFC模型的最小步骤。 ///
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--;

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

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器

你可能感兴趣的文章