예제 #1
0
        static void Main(string[] args)
        {
            DatabaseIfc db       = new DatabaseIfc(ModelView.Ifc4DesignTransfer);
            IfcBuilding building = new IfcBuilding(db, "IfcBuilding")
            {
            };
            IfcProject project = new IfcProject(building, "IfcProject", IfcUnitAssignment.Length.Millimetre)
            {
            };

            //IfcBuildingStorey storey = new IfcBuildingStorey(building, "Ground Floor", 0);
            IfcMaterial      masonryFinish          = new IfcMaterial(db, "Masonry - Brick - Brown");
            IfcMaterial      masonry                = new IfcMaterial(db, "Masonry");
            IfcMaterialLayer layerFinish            = new IfcMaterialLayer(masonryFinish, 110, "Finish");
            IfcMaterialLayer airInfiltrationBarrier = new IfcMaterialLayer(db, 50, "Air Infiltration Barrier")
            {
                IsVentilated = IfcLogicalEnum.TRUE
            };
            IfcMaterialLayer    structure        = new IfcMaterialLayer(masonry, 110, "Core");
            string              name             = "Double Brick - 270";
            IfcMaterialLayerSet materialLayerSet = new IfcMaterialLayerSet(new List <IfcMaterialLayer>()
            {
                layerFinish, airInfiltrationBarrier, structure
            }, name);
            IfcMaterialLayerSetUsage materialLayerSetUsage = new IfcMaterialLayerSetUsage(materialLayerSet, IfcLayerSetDirectionEnum.AXIS2, IfcDirectionSenseEnum.POSITIVE, 0);

            db.NextObjectRecord = 300;
            IfcWallType wallType = new IfcWallType(name, materialLayerSet, IfcWallTypeEnum.NOTDEFINED)
            {
            };
            IfcWallStandardCase wallStandardCase = new IfcWallStandardCase(building, materialLayerSetUsage, new IfcAxis2Placement3D(new IfcCartesianPoint(db, 0, 0, 0)), 5000, 2000)
            {
            };
        }
예제 #2
0
        public static CcManufacturerProduct LoadProductDataTemplate(string key, string classificationCode)
        {
            IfcProject            ifcProject            = Workspace.Current.Documents[key].Project;
            CcManufacturerProduct ccProductDataTemplate = new CcManufacturerProduct(classificationCode);

            return(ccProductDataTemplate);
        }
예제 #3
0
        public List <XTreeNode> CreateProjectTree(string projectId)
        {
            List <XTreeNode> projectStructure = new List <XTreeNode>();

            try
            {
                string modelPath = GetFolderPath(projectId) + projectId + ".ifc";
                model = IfcStore.Open(modelPath);
                IfcBuilding ifcBuilding = model.Instances.OfType <IfcBuilding>().FirstOrDefault();
                if (ifcBuilding != null)
                {
                    building = new XPreviewBuilding(ifcBuilding);
                    IfcProject project = model.Instances.OfType <IfcProject>().FirstOrDefault();
                    if (project != null)
                    {
                        IfcUtils  utils       = new IfcUtils();
                        XTreeNode projectNode = utils.CreateProjectHierarchy(project);
                        if (projectNode != null)
                        {
                            projectStructure.Add(projectNode);
                        }
                    }
                    model.Close();
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }
            return(projectStructure);
        }
예제 #4
0
        /// <summary>
        ///  Initialisiert ein leeres Projekt
        /// </summary>
        private static IfcStore createandInitModel(string projectName,
                                                   string editorsFamilyName,
                                                   string editorsGivenName,
                                                   string editorsOrganisationName,
                                                   out IfcProject project)
        {
            //first we need to set up some credentials for ownership of data in the new model
            var credentials = new XbimEditorCredentials
            {
                ApplicationDevelopersName = "HTW Dresden for DDBIM",
                ApplicationFullName       = System.Reflection.Assembly.GetExecutingAssembly().FullName,
                ApplicationIdentifier     = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name,
                ApplicationVersion        = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(),
                EditorsFamilyName         = editorsFamilyName,
                EditorsGivenName          = editorsGivenName,
                EditorsOrganisationName   = editorsOrganisationName
            };

            var model = IfcStore.Create(credentials, XbimSchemaVersion.Ifc2X3, XbimStoreType.EsentDatabase);

            //Begin a transaction as all changes to a model are ACID
            using (var txn = model.BeginTransaction("Initialise Model"))
            {
                //create a project
                project = model.Instances.New <IfcProject>();
                //set the units to SI (metres)
                project.Initialize(ProjectUnits.SIUnitsUK);
                project.Name = projectName;
                project.UnitsInContext.SetOrChangeSiUnit(IfcUnitEnum.LENGTHUNIT, IfcSIUnitName.METRE, null);
                //now commit the changes, else they will be rolled back at the end of the scope of the using statement
                txn.Commit();
            }
            return(model);
        }
예제 #5
0
        //Demonstration of approach to filter out fire rated walls into seperate IFC file
        static void Main(string[] args)
        {
            DatabaseIfc db = new DatabaseIfc(args[0]);

            DuplicateOptions duplicateOptions = new DuplicateOptions(db.Tolerance);

            duplicateOptions.DuplicateDownstream = false;
            DatabaseIfc filteredDb = new DatabaseIfc(db);
            IfcProject  project    = filteredDb.Factory.Duplicate(db.Project, duplicateOptions) as IfcProject;

            duplicateOptions.DuplicateDownstream = true;

            List <IfcWall> walls = db.Project.Extract <IfcWall>();

            foreach (IfcWall wall in walls)
            {
                IfcPropertySingleValue property = wall.FindProperty("FireRating", true) as IfcPropertySingleValue;
                if (property != null && property.NominalValue != null)
                {
                    string value = property.NominalValue.ValueString.Trim();
                    if (value != "0")
                    {
                        filteredDb.Factory.Duplicate(wall, duplicateOptions);
                    }
                }
            }

            filteredDb.WriteFile(args[1]);
        }
예제 #6
0
 public XbimModelViewModel(IfcProject project, IXbimViewModel parent)
 {
     xbimModel           = project.ModelOf as XbimModel;
     _project            = project;
     this.CreatingParent = parent;
     IEnumerable subs = this.Children; //call this once to preload first level of hierarchy
 }
예제 #7
0
        private static IfcStore CreateAndInitModel(string projectName)
        {
            var credentials = new XbimEditorCredentials
            {
                ApplicationDevelopersName = "xbim developer",
                ApplicationFullName       = "T-Rex",
                ApplicationIdentifier     = "T-Rex",
                ApplicationVersion        = "0.2",
                EditorsFamilyName         = "Team",
                EditorsGivenName          = "xbim",
                EditorsOrganisationName   = "xbim developer"
            };

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

            using (ITransaction transaction = model.BeginTransaction("Initialise Model"))
            {
                IfcProject project = model.Instances.New <IfcProject>();
                project.Initialize(ProjectUnits.SIUnitsUK);
                project.Name = projectName;
                transaction.Commit();
            }

            return(model);
        }
        static void Main(string[] args)
        {
            DatabaseIfc db      = new DatabaseIfc(Console.In);
            IfcProject  project = db.Project;

            Console.Out.Write("Number of Stories in file :" + project.Extract <IfcBuildingStorey>().Count);
        }
예제 #9
0
        /// <summary>
        /// Sets up the basic parameters any model must provide, units, ownership etc
        /// </summary>
        /// <param name="projectName">Name of the project</param>
        /// <returns></returns>
        private XbimModel CreateandInitModel(string projectName)
        {
            XbimModel model = XbimModel.CreateModel(projectName + ".xBIM");;  //create an empty model

            //Begin a transaction as all changes to a model are transacted
            using (XbimReadWriteTransaction txn = model.BeginTransaction("Initialise Model"))
            {
                //do once only initialisation of model application and editor values
                model.DefaultOwningUser.ThePerson.GivenName              = "John";
                model.DefaultOwningUser.ThePerson.FamilyName             = "Bloggs";
                model.DefaultOwningUser.TheOrganization.Name             = "Department of Building";
                model.DefaultOwningApplication.ApplicationIdentifier     = "Construction Software inc.";
                model.DefaultOwningApplication.ApplicationDeveloper.Name = "Construction Programmers Ltd.";
                model.DefaultOwningApplication.ApplicationFullName       = "Ifc sample programme";
                model.DefaultOwningApplication.Version = "2.0.1";

                //set up a project and initialise the defaults

                IfcProject project = model.Instances.New <IfcProject>();
                project.Initialize(ProjectUnits.SIUnitsUK);
                project.Name = "testProject";
                project.OwnerHistory.OwningUser        = model.DefaultOwningUser;
                project.OwnerHistory.OwningApplication = model.DefaultOwningApplication;

                //validate and commit changes
                if (model.Validate(txn.Modified(), Console.Out) == 0)
                {
                    txn.Commit();
                    return(model);
                }
            }
            return(null); //failed so return nothing
        }
예제 #10
0
        static void Main(string[] args)
        {
            DatabaseIfc db       = new DatabaseIfc(ModelView.Ifc4DesignTransfer);
            IfcBuilding building = new IfcBuilding(db, "IfcBuilding")
            {
            };
            IfcProject project = new IfcProject(building, "IfcProject", IfcUnitAssignment.Length.Millimetre)
            {
            };

            //IfcBuildingStorey storey = new IfcBuildingStorey(building, "Ground Floor", 0);
            IfcMaterial      masonryFinish          = new IfcMaterial(db, "Masonry - Brick - Brown");
            IfcMaterial      masonry                = new IfcMaterial(db, "Masonry");
            IfcMaterialLayer layerFinish            = new IfcMaterialLayer(masonryFinish, 110, "Finish");
            IfcMaterialLayer airInfiltrationBarrier = new IfcMaterialLayer(db, 50, "Air Infiltration Barrier")
            {
                IsVentilated = IfcLogicalEnum.TRUE
            };
            IfcMaterialLayer    structure        = new IfcMaterialLayer(masonry, 110, "Core");
            string              name             = "Double Brick - 270";
            IfcMaterialLayerSet materialLayerSet = new IfcMaterialLayerSet(new List <IfcMaterialLayer>()
            {
                layerFinish, airInfiltrationBarrier, structure
            }, name);

            db.NextObjectRecord = 300;
            IfcWallType wallType = new IfcWallType(name, materialLayerSet, IfcWallTypeEnum.NOTDEFINED)
            {
            };
            // todo implement rhinocommon overload IfcWallStandardCase wallStandardCase = new IfcWallStandardCase(building, wallType, new Line(0, 0, 0, 5000, 0, 0), 2000, 0, true, null) {  };
        }
예제 #11
0
        static void Main(string[] args)
        {
            DatabaseIfc               db          = new DatabaseIfc(Console.In);
            IfcProject                project     = db.Project;
            IfcSpatialElement         rootElement = project.RootElement;
            List <IfcBuildingElement> elements    = project.Extract <IfcBuildingElement>();
            List <IfcFacetedBrep>     breps       = new List <IfcFacetedBrep>();

            foreach (IfcBuildingElement element in elements)
            {
                List <IfcRepresentation> reps = element.Representation.Representations;
                foreach (IfcRepresentation rep in reps)
                {
                    IfcShapeRepresentation sr = rep as IfcShapeRepresentation;
                    if (sr != null)
                    {
                        List <IfcRepresentationItem> items = sr.Items;
                        foreach (IfcRepresentationItem item in items)
                        {
                            IfcFacetedBrep fb = item as IfcFacetedBrep;
                            if (fb != null)
                            {
                                breps.Add(fb);
                            }
                        }
                    }
                }
            }
        }
예제 #12
0
        /// <summary>
        /// Set up the Model Object
        /// </summary>
        private void ModelSetUp()
        {
            using (XbimReadWriteTransaction trans = Model.BeginTransaction("Model initialization"))
            {
                Assembly        assembly = Assembly.GetExecutingAssembly();
                FileVersionInfo fvi      = FileVersionInfo.GetVersionInfo(assembly.Location);
                string          version  = fvi.ProductVersion;

                Model.DefaultOwningApplication.ApplicationIdentifier     = fvi.Comments;
                Model.DefaultOwningApplication.ApplicationDeveloper.Name = fvi.CompanyName;
                Model.DefaultOwningApplication.ApplicationFullName       = fvi.ProductName;
                Model.DefaultOwningApplication.Version = fvi.ProductVersion;
                //TODO add correct IfcPersonAndOrganization to DefaultOwningUser
                Model.DefaultOwningUser.ThePerson.FamilyName = "Unknown";
                Model.DefaultOwningUser.TheOrganization.Name = "Unknown";
                if (Model.Header == null)
                {
                    Model.Header = new IfcFileHeader(IfcFileHeader.HeaderCreationMode.InitWithXbimDefaults);
                }
                Model.Header.FileDescription.Description.Clear();
                Model.Header.FileDescription.Description.Add("ViewDefinition[CoordinationView]");
                Model.Header.FileName.Name = Path.GetFileName(FileName);
                Model.Header.FileName.AuthorName.Add("4Projects");
                Model.Header.FileName.AuthorizationName = "4Projects";
                IfcProject project = Model.Instances.New <IfcProject>();
                //set world coordinate system
                XBimContext.WCS = Model.Instances.New <IfcAxis2Placement3D>();
                XBimContext.WCS.SetNewDirectionOf_XZ(1, 0, 0, 0, 0, 1);
                XBimContext.WCS.SetNewLocation(0, 0, 0);
                trans.Commit();
            }
        }
예제 #13
0
        public void CanConstructAProject()
        {
            var id = new IfcGloballyUniqueId(TestId());
            var p  = new IfcProject(id);

            Assert.NotNull(p);
        }
예제 #14
0
        private static IfcBuilding CreateBuilding(IfcStore model, IfcProject project, string name)
        {
            var building = model.Instances.New <IfcBuilding>(b => b.Name = name);

            project.AddBuilding(building);
            return(building);
        }
예제 #15
0
        static void Main(string[] args)
        {
            DatabaseIfc            db          = new DatabaseIfc(Console.In);
            IfcProject             project     = db.Project;
            IfcSpatialElement      rootElement = project.RootElement();
            List <IfcBuiltElement> elements    = project.Extract <IfcBuiltElement>();         //IfcBuiltElement renamed from IfcBuildingElement
            List <IfcFacetedBrep>  breps       = new List <IfcFacetedBrep>();

            foreach (IfcBuiltElement element in elements)
            {
                IfcProductDefinitionShape representation = element.Representation;
                if (representation != null)
                {
                    foreach (IfcShapeModel rep in representation.Representations)
                    {
                        IfcShapeRepresentation sr = rep as IfcShapeRepresentation;
                        if (sr != null)
                        {
                            foreach (IfcRepresentationItem item in sr.Items)
                            {
                                IfcFacetedBrep fb = item as IfcFacetedBrep;
                                if (fb != null)
                                {
                                    breps.Add(fb);
                                }
                            }
                        }
                    }
                }
            }
        }
예제 #16
0
        //sample to show how to create a model from scratch

        static void Main(string[] args)
        {
            Logger.Debug("Creating Model...");
            XbimModel model = CreateModel("NewModel");

            if (model != null)
            {
                using (XbimReadWriteTransaction txn = model.BeginTransaction()) //start a readwrite transaction
                {
                    try
                    {
                        IfcProject project = model.Instances.New <IfcProject>(); //Project Created

                        txn.Commit();                                            //commit the changes if nothing went wrong
                    }
                    catch (Exception e)
                    {
                        Logger.DebugFormat("Error {0}\nRolling back changes.....", e.Message);
                    }
                }
                model.SaveAs("NewModel.ifc", XbimStorageType.IFC); //export as an Ifc File
                model.Close();                                     //close the model and release all resources and handles
            }

            Logger.Debug("Model Created Ended...");
            Console.ReadLine();
            // CreateProject
        }
예제 #17
0
        private void openFileButton_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();

            ofd.Filter = "ifc|*.ifc";
            ofd.ShowDialog();

            DatabaseIfc               db          = new DatabaseIfc(ofd.FileName);
            IfcProject                project     = db.Project;
            IfcSpatialElement         rootElement = project.RootElement;
            List <IfcBuildingElement> elements    = project.Extract <IfcBuildingElement>();
            List <IfcFacetedBrep>     breps       = new List <IfcFacetedBrep>();

            foreach (IfcBuildingElement element in elements)
            {
                //outputLabel.Content += element.Name+ "\n";
                IfcProductRepresentation representation = element.Representation;
                if (representation != null)
                {
                    foreach (IfcRepresentation rep in representation.Representations)
                    {
                        IfcShapeRepresentation sr = rep as IfcShapeRepresentation;
                        if (sr != null)
                        {
                            foreach (IfcRepresentationItem item in sr.Items)
                            {
                                Debug.WriteLine(item.GetType());
                                IfcFacetedBrep fb = item as IfcFacetedBrep;
                                if (fb != null)
                                {
                                    breps.Add(fb);
                                    outputLabel.Content += fb + "\n";
                                    /// Each IfcFacetedBrep has one IfcClosedShell called "Outer".
                                    /// IfcClosedShell has several IfcFaces called CfsFaces
                                    //foreach (var face in fb.Outer.CfsFaces)
                                    //{
                                    //    /// IfcFace has several IfcFaceOuterBounds called bounds
                                    //    foreach(var bound in face.Bounds)
                                    //    {
                                    //        /// Each IfcFaceOuterBound inherited from IfcFacetedBrep has IfcPolyLoop
                                    //        var loop = bound.Bound as IfcPolyloop;
                                    //        if(loop != null)
                                    //        {
                                    //            foreach(var point in loop.Polygon)
                                    //            {
                                    //               //point.Coordinates;
                                    //                outputLabel.Content += point.Coordinates + "\n";
                                    //            }
                                    //        }
                                    //    }
                                    //}
                                    //outputLabel.Content += fb.ToString() + "\n";
                                }
                            }
                        }
                    }
                }
            }
        }
예제 #18
0
        public void CreateProductIfc(ProductIfcRequest request,
                                     Stream outputStream)
        {
            IfcPerson person = IfcInit.CreatePerson(request.owner.person.givenName,
                                                    request.owner.person.familyName,
                                                    request.owner.person.identifier);
            IfcOrganization organization =
                IfcInit.CreateOrganization(request.owner.organization.name,
                                           request.owner.organization.description,
                                           request.owner.organization.identifier);
            IfcOrganization applicationOrganization =
                IfcInit.CreateOrganization(request.owner.application.organization.name,
                                           request.owner.application.organization.description,
                                           request.owner.application.organization.identifier);
            IfcApplication application =
                IfcInit.CreateApplication(applicationOrganization,
                                          request.owner.application.version,
                                          request.owner.application.name,
                                          request.owner.application.identifier);
            IfcOwnerHistory ownerHistory =
                IfcInit.CreateOwnerHistory(person, organization, application);

            IfcProject project = IfcInit.CreateProject(request.project.name,
                                                       request.project.description,
                                                       ownerHistory);
            IfcSite site = IfcInit.CreateSite(null, null, ownerHistory);

            project.Aggregate(site, ownerHistory);
            IfcBuilding building =
                IfcInit.CreateBuilding(null, null, ownerHistory, site.ObjectPlacement);

            site.Aggregate(building, ownerHistory);
            IfcBuildingStorey storey =
                IfcInit.CreateBuildingStorey(null, null, ownerHistory, building.ObjectPlacement);

            building.Aggregate(storey, ownerHistory);
            IfcProduct product;

            switch (request.product.type)
            {
            default:
                product = IfcInit.CreateProxy(request.product.name,
                                              request.product.description,
                                              ownerHistory,
                                              storey.ObjectPlacement,
                                              null);
                break;
            }
            List <IfcRepresentationContext> contextList =
                new List <IfcRepresentationContext> (project.RepresentationContexts);

            product.Representation =
                CreateProductRepresentation(contextList, request.product.representations);
            storey.Contains(product, ownerHistory);
            project.SerializeToStep(outputStream, request.schema.ToString(), null);
            return;
        }
예제 #19
0
파일: Document.cs 프로젝트: JoinCAD/IFC-gen
        public IfcProject AddProject(string name, string description)
        {
            var p = new IfcProject(IfcGuid.IfcGuid.ToIfcGuid(Guid.NewGuid()));

            p.Name        = name;
            p.Description = description;
            storage.AddInstance(p);
            return(p);
        }
예제 #20
0
 public ProjectType(IfcProject ifcProject, CoBieLiteHelper helper)
     : this()
 {
     //  _ifcProject = ifcProject;
     externalEntityName = helper.ExternalEntityName(ifcProject);
     externalID         = helper.ExternalEntityIdentity(ifcProject);
     externalSystemName = helper.ExternalSystemName(ifcProject);
     ProjectName        = ifcProject.Name;
     ProjectDescription = ifcProject.Description;
 }
예제 #21
0
파일: Document.cs 프로젝트: JoinCAD/IFC-gen
        public IfcSite AddSite(IfcProject project, string name = "", string description = "")
        {
            var s = new IfcSite(IfcGuid.IfcGuid.ToIfcGuid(Guid.NewGuid()));

            s.Name        = name;
            s.Description = description;
            storage.AddInstance(s);
            CreateAggregationRelationship(project, s);
            return(s);
        }
예제 #22
0
        protected override Project Mapping(IfcProject source, Project target)
        {
            var helper = ((IfcToCOBieLiteUkExchanger)Exchanger).Helper;

            target.ExternalEntity = helper.ExternalEntityName(source);
            target.ExternalId     = helper.ExternalEntityIdentity(source);
            target.Name           = source.Name;
            target.Description    = source.Description;
            return(target);
        }
예제 #23
0
 private static void HandleBuildings(IfcProject ifcProject, IEnumerable <IIfcBuilding> buildings)
 {
     foreach (var building in buildings)
     {
         Console.WriteLine("description: " + building.BuildingAddress.Description);
         var storeys = building.BuildingStoreys;
         var site    = ifcProject.Sites.FirstOrDefault();
         HandleStoreys(storeys, site.RefLongitude.Value.AsDouble, site.RefLatitude.Value.AsDouble);
     }
 }
예제 #24
0
        public void ExtrudeAndRevolveTest()
        {
            //Set up project hierarchy
            IfcProject project = IfcInit.CreateProject(null, null, null);
            IfcSite    site    = IfcInit.CreateSite(null, null, null);

            project.Aggregate(site, null);
            IfcBuilding building = IfcInit.CreateBuilding(null, null, null, null);

            site.Aggregate(building, null);
            IfcBuildingStorey storey = IfcInit.CreateBuildingStorey(null, null, null, null);

            building.Aggregate(storey, null);

            //Create shape representation
            // -- extruded profile shape
            IfcPolyline outerCurve = IfcGeom.CreatePolyLine(new List <double[]>()
            {
                new double[] { -0.5, -0.5 },
                new double[] { -0.5, 0.5 },
                new double[] { 0.5, 0.5 },
                new double[] { 0.5, -0.5 },
                new double[] { -0.5, -0.5 }
            });
            IfcProfileDef profileDef = new IfcArbitraryClosedProfileDef(IfcProfileTypeEnum.AREA,
                                                                        null,
                                                                        outerCurve);
            IfcRepresentationItem extrudedRepresentation = profileDef.Extrude(1).Rotate(new double[] { 45, 0, 45 }).Translate(new double[] { -2, 0, 0 });

            // -- revolved profile shape
            IfcRepresentationItem revolvedRepresentation = profileDef.Revolve(-45,
                                                                              new IfcAxis1Placement(new IfcCartesianPoint(1, 0, 0),
                                                                                                    new IfcDirection(0, 1, 0)),
                                                                              null);

            //Create product with representation and place in storey
            var contextEnum = project.RepresentationContexts.GetEnumerator();

            contextEnum.MoveNext();
            IfcShapeRepresentation shapeRepresentation =
                new IfcShapeRepresentation(contextEnum.Current,
                                           new IfcLabel("extruded square"),
                                           new IfcLabel("SweptSolid"),
                                           new IfcRepresentationItem[] { extrudedRepresentation, revolvedRepresentation });
            IfcProxy product = IfcInit.CreateProxy(null, null, null, storey.ObjectPlacement, null);

            product.Representation = new IfcProductDefinitionShape(null, null, new IfcRepresentation[] { shapeRepresentation });;
            storey.Contains(product, null);

            //Write to IFC file
            using (FileStream fs = File.Create("./swept_geom_test.ifc"))
            {
                project.SerializeToStep(fs, "IFC2X3", null);
            }
        }
예제 #25
0
        /// <summary>
        /// Set the global units in the UnitsInContext property
        /// </summary>
        private IfcUnitAssignment GetProjectUnitAssignment()
        {
            IfcProject ifcProject = Model.IfcProject;

            if (ifcProject.UnitsInContext == null)
            {
                ifcProject.UnitsInContext = Model.Instances.New <IfcUnitAssignment>();
            }

            return(ifcProject.UnitsInContext);
        }
예제 #26
0
        private void ViewModel()
        {
            IfcProject project = Model.IfcProject;

            if (project != null)
            {
                ChildrenPath = "Children";
                ObservableCollection <XbimModelViewModel> svList = new ObservableCollection <XbimModelViewModel>();
                svList.Add(new XbimModelViewModel(project, null));
                HierarchySource = svList;
            }
        }
예제 #27
0
        private void ViewModel()
        {
            IfcProject project = Model.IfcProject as IfcProject;

            if (project != null)
            {
                this.ChildrenBinding = new Binding("Children");
                ObservableCollection <XbimModelViewModel> svList = new ObservableCollection <XbimModelViewModel>();
                svList.Add(new XbimModelViewModel(project, null));
                this.HierarchySource = svList;
            }
        }
예제 #28
0
        public XTreeNode CreateProjectHierarchy(IfcProject project)
        {
            XTreeNode projectNode = null;

            if (project != null)
            {
                projectNode = CreateObject(project);

                PrintHierarchy(project, projectNode);
            }
            return(projectNode);
        }
예제 #29
0
        static void Main(string[] args)
        {
            var dbInitial = new DatabaseIfc(ModelView.Ifc4NotAssigned);

            dbInitial.Factory.Options.GenerateOwnerHistory = false;

            var site = new IfcSite(dbInitial, "site")
            {
                Guid = new Guid("aa4019f8-2584-44a1-a132-c17dfff69c41")
            };
            var project = new IfcProject(dbInitial, "GeomRep")
            {
                Guid = new Guid("94d4ddac-9120-4fb9-bea0-7a414ee725d4")
            };

            new IfcRelAggregates(project, new List <IfcObjectDefinition>()
            {
                site
            })
            {
                Guid = new Guid("5e1fd0e5-b005-fe11-501e-5caff01dc1ad")
            };

            IfcAxis2Placement3D placement1       = new IfcAxis2Placement3D(new IfcCartesianPoint(dbInitial, 2, 5, 1));
            IfcLocalPlacement   objectPlacement1 = new IfcLocalPlacement(site.ObjectPlacement, placement1);

            IfcAxis2Placement3D placement2       = new IfcAxis2Placement3D(new IfcCartesianPoint(dbInitial, 14, 5, 1));
            IfcLocalPlacement   objectPlacement2 = new IfcLocalPlacement(site.ObjectPlacement, placement2);


            var profile1 = new IfcRectangleProfileDef(dbInitial, "rectangleProfileDef", 4, 6);
            IfcExtrudedAreaSolid      extrudedAreaSolid1 = new IfcExtrudedAreaSolid(profile1, 1.35);
            IfcProductDefinitionShape shape1             = new IfcProductDefinitionShape(new IfcShapeRepresentation(extrudedAreaSolid1));

            var profile2 = new IfcRectangleProfileDef(dbInitial, "rectangleProfileDef", 5, 8);
            IfcExtrudedAreaSolid      extrudedAreaSolid2 = new IfcExtrudedAreaSolid(profile2, 4.1);
            IfcProductDefinitionShape shape2             = new IfcProductDefinitionShape(new IfcShapeRepresentation(extrudedAreaSolid2));


            var proxy1 = new IfcBuildingElementProxy(site, objectPlacement1, shape1)
            {
                Name = "Cuboid1",
                Guid = new Guid("fbc7f4b2-177d-4875-88bb-d3b44115bbaa")
            };
            var proxy2 = new IfcBuildingElementProxy(site, objectPlacement2, shape2)
            {
                Name = "Cuboid2",
                Guid = new Guid("f8e196cb-c7d9-4d53-9885-0f687706727a")
            };


            dbInitial.WriteFile("cube_double.ifc");
        }
예제 #30
0
        public static void InitializeManufacturerFile(string key, string manufacurerName, string manufacturerDescription)
        {
            IfcProject ifcProject = Workspace.Current.Documents[key].Project;

            ifcProject.Name     = manufacurerName;
            ifcProject.LongName = manufacturerDescription;

            IfcSite site = ifcProject.Sites.AddNewSite();

            site.Name     = manufacurerName;
            site.LongName = manufacturerDescription;
        }
예제 #31
0
		internal void GenerateExample(string path,ModelView modelView) 
		{
			STPModelData md = new STPModelData(false,modelView);
			md.NextObjectRecord = 50;
			IfcBuilding building = new IfcBuilding(md, "IfcBuilding") { GlobalId = "39t4Pu3nTC4ekXYRIHJB9W"};
			building.ContainsElements[0].GlobalId = "3Sa3dTJGn0H8TQIGiuGQd5";
			building.Comments.Add("defines the default building (as required as the minimum spatial element) ");
			md.NextObjectRecord = 100;
			IfcProject project = new IfcProject(building, "IfcProject", GGYM.Units.Length.mm) { GlobalId = "0$WU4A9R19$vKWO$AdOnKA"};
			project.IsDecomposedBy[0].GlobalId = "091a6ewbvCMQ2Vyiqspa7a";
			project.RepresentationContexts[0].Comments.Add("general entities required for all IFC data sets, defining the context for the exchange");
			md.NextObjectRecord = 200;
			GenerateData(md,building);
			string filePath = Path.Combine(path,this.GetType().Name + ".ifc");
			if (File.Exists(filePath))
			{
				string[] newLines = md.ToString().Split(new char[] { '\r' , '\n' },StringSplitOptions.RemoveEmptyEntries);
				List<string> existingLines = new List<string>( File.ReadAllLines(filePath));
				existingLines.RemoveAll(x => string.IsNullOrEmpty(x));
				
				if (newLines.Length == existingLines.Count)
				{
					bool identical = true;
					for (int icounter = 0; icounter < newLines.Length; icounter++)
					{
						string s1 = newLines[icounter], s2 = existingLines[icounter];
						if (s1.StartsWith("/* time_stamp */ ") && s2.StartsWith("/* time_stamp */ "))
							continue;
						if (string.Compare(s1, s2, true) != 0)
						{
							identical = false;
							break;
						}
					}
					if (identical)
						return;
				}
			}
			md.WriteFile(filePath); 
		}
예제 #32
0
 //: this()
 protected BbProject(Guid guid, string name, string description, string objectType, string longname, string phase)
 {
     _ifcProject = new IfcProject
     {
         GlobalId = IfcGloballyUniqueId.ConvertToIfcGuid(guid),
         OwnerHistory = BbHeaderSetting.Setting3D.IfcOwnerHistory,
         Name = name,
         Description = description,
         ObjectType = objectType,
         LongName = longname,
         Phase = phase,
         RepresentationContexts = new List<IfcRepresentationContext>(),
         UnitsInContext = BbHeaderSetting.Setting3D.IfcUnitAssignment,
     };
     _ifcProject.RepresentationContexts.Add(BbHeaderSetting.Setting3D.GeometricRepresentationContext);
 }
예제 #33
0
 //protected BbProject()
 //{
 //}
 //protected BbProject(string name)
 //    : this(Guid.NewGuid(), name, null, null, null, null)
 //{
 //}
 protected BbProject(IfcProject ifcProject)
 {
     _ifcProject = ifcProject;
 }