IFC

IFC

关注
发信
关注(28)粉丝(399)

xBIM IFC 墙壁案例

目录

一、使用代码生成IFC 模型

其实使用代码的形式去生成模型一堵墙还是要做很多的工作。

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()

        {

            //first create and initialise a model called Hello Wall

            Console.WriteLine("Initialising the IFC Project....");

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

            {

                if (model != null)

                {

                    IfcBuilding building = CreateBuilding(model, "Default Building");

                    IfcWallStandardCase wall = CreateWall(model, , , );

                    if (wall != null) AddPropertiesToWall(model, wall);

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

                    {

                        building.AddElement(wall);

                        txn.Commit();

                    }

                    if (wall != null)

                    {

                        try

                        {

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

                            //保存到文件

                            model.SaveAs("HelloWallIfc4.ifc", IfcStorageType.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 void LaunchNotepad(string fileName)

        {

            Process p;

            try

            {

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

                p.Start();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Exception Occurred :{0},{1}",

                          ex.Message, ex.StackTrace);

            }

        }

        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();

                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,IfcStore 是IFC4 格式存放在内存中而不是数据库

            //如果模型大于50MB的Ifc或者需要强大的事务处理，数据库在性能方面通常会更好

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

            // 启动事务、将所有的模型更改为 ACID

            using (var txn = model.BeginTransaction("Initialise Model"))

            {

                //常见项目信息

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

                //设置单位   这里是英制

                project.Initialize(ProjectUnits.SIUnitsUK);

                project.Name = projectName;

                //提交修改

                txn.Commit();

            }

            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>();

                wall.Name = "A Standard rectangular wall";

                // 墙的矩形剖面

                var rectProf = model.Instances.New<IfcRectangleProfileDef>();

                rectProf.ProfileType = IfcProfileTypeEnum.AREA;

                rectProf.XDim = width;

                rectProf.YDim = length;

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

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

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

                rectProf.Position.Location = insertPoint;

                //模型区域实心

                var body = model.Instances.New<IfcExtrudedAreaSolid>();

                body.Depth = height;

                body.SweptArea = rectProf;

                body.ExtrudedDirection = model.Instances.New<IfcDirection>();

                body.ExtrudedDirection.SetXYZ(, , );

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

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

                origin.SetXYZ(, , );

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

                body.Position.Location = origin;

                //创建一个定义形状来保存几何

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

                var modelContext = model.Instances.OfType<IfcGeometricRepresentationContext>().FirstOrDefault();

                shape.ContextOfItems = modelContext;

                shape.RepresentationType = "SweptSolid";

                shape.RepresentationIdentifier = "Body";

                shape.Items.Add(body);

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

                var rep = model.Instances.New<IfcProductDefinitionShape>();

                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子句：IfcWallStandard依赖于提供一个IfcMaterialLayerSetUsage

                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("[email protected]"));

            });

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

            {

                prv.Name = "IfcPropertyReferenceValue:Telecom";

                prv.PropertyReference = ifcTelecomAddress;

            });

            //设置模型元素数量

            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;

            });

            //lets create the 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文件

生成的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'),$,$,('[email protected]'),$,$);

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

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

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

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

ENDSEC;

END-ISO--;
05-11 18:26
Powered by LMLPHP ©2024 IFC 0.052345