예제 #1
0
        private void DoExport(object sender, RoutedEventArgs e)
        {
            BtnGenerate.IsEnabled = false;

            if (_cobieWorker == null)
            {
                _cobieWorker = new CobieLiteWorker();
                _cobieWorker.Worker.ProgressChanged += WorkerProgressChanged;
                _cobieWorker.Worker.RunWorkerCompleted += WorkerCompleted;
            }
            //get Excel File Type
            var excelType = ExportFormat.SelectedItem.ToString().GetExcelType();
            //set filters

            // todo: restore commented lines in params.

            //RoleFilter filterRoles = SetRoles();
            //if (!chkBoxNoFilter.Checked)
            //{
            //    _assetfilters.ApplyRoleFilters(filterRoles);
            //    _assetfilters.FlipResult = chkBoxFlipFilter.Checked;
            //}

            //set parameters
            var args = new Params
            {
                // ModelFile = txtPath.Text,
                // TemplateFile = txtTemplate.Text,
                // Roles = filterRoles,
                ExportType = excelType,
                FlipFilter = false,
                OpenExcel = false,
                FilterOff = false,
                // ExtId = chkBoxIds.Checked ? EntityIdentifierMode.IfcEntityLabels : EntityIdentifierMode.GloballyUniqueIds,
                // SysMode = SetSystemMode(),
                // Filter = chkBoxNoFilter.Checked ? new OutPutFilters() : _assetfilters,
                // ConfigFile = ConfigFile.FullName,
                // Log = chkBoxLog.Checked,
            };
            //run worker
            _cobieWorker.Run(args);
        }
예제 #2
0
 /// <summary>
 /// Get the facility from the COBie Excel sheets
 /// </summary>
 /// <param name="parameters"></param>
 /// <returns></returns>
 private List<Facility> GeneratelXmlFacility(Params parameters)
 {
     var facilities = new List<Facility>();
     var facility = Facility.ReadXml(parameters.ModelFile);
     if (facility != null)
     {
         facilities.Add(facility);
     }
     return facilities;
 }
예제 #3
0
 /// <summary>
 /// Run the worker
 /// </summary>
 /// <param name="args"></param>
 internal void Run(Params args)
 {
     Worker.RunWorkerAsync(args);
 }
예제 #4
0
        /// <summary>
        /// Generate Facilities for a xbim or ifc type file
        /// </summary>
        /// <param name="parameters"></param>
        /// <param name="fileExt"></param>
        /// <returns></returns>
        private List<Facility> GenerateFileFacility(Params parameters, string fileExt)
        {
            var facilities = new List<Facility>();
            using (var model = new XbimModel())
            {
                if (fileExt.Equals(".xbim", StringComparison.OrdinalIgnoreCase))
                {
                    model.Open(parameters.ModelFile, Xbim.XbimExtensions.XbimDBAccess.Read, Worker.ReportProgress);
                }
                else
                {
                    var xbimFile = Path.ChangeExtension(parameters.ModelFile, "xbim");
                    model.CreateFrom(parameters.ModelFile, xbimFile, Worker.ReportProgress, true, true);

                }
                var ifcToCoBieLiteUkExchanger = new IfcToCOBieLiteUkExchanger(model, facilities, Worker.ReportProgress, parameters.Filter, parameters.ConfigFile, parameters.ExtId, parameters.SysMode);
                facilities = ifcToCoBieLiteUkExchanger.Convert();
            }
            return facilities;
        }
예제 #5
0
 /// <summary>
 /// Get the facility from the COBie Excel sheets
 /// </summary>
 /// <param name="parameters"></param>
 /// <returns></returns>
 private List<Facility> GeneratelExcelFacility(Params parameters)
 {
     var facilities = new List<Facility>();
     string msg;
     var facility = Facility.ReadCobie(parameters.ModelFile, out msg, parameters.TemplateFile);
     if (facility != null)
     {
         facilities.Add(facility);
     }
     return facilities;
 }
예제 #6
0
        /// <summary>
        /// Generate Facilities for a xbimf federated file
        /// </summary>
        /// <param name="parameters"></param>
        /// <returns></returns>
        private List<Facility> GenerateFedFacility(Params parameters)
        {
            var facilities = new List<Facility>();
            try
            {

                if (_fedModelProxy.IsFederation)
                {
                    var fedFilters = parameters.Filter.SetFedModelFilter(GetFileRoles());
                    var rolesFacilities = new Dictionary<RoleFilter, List<Facility>>();
                    foreach (var item in fedFilters)
                    {
                        var ifcToCoBieLiteUkExchanger = new IfcToCOBieLiteUkExchanger(item.Key, new List<Facility>(),
                            Worker.ReportProgress, item.Value, parameters.ConfigFile, parameters.ExtId,
                            parameters.SysMode);
                        ifcToCoBieLiteUkExchanger.ReportProgress.Progress = Worker.ReportProgress;
                        var rolesFacility = ifcToCoBieLiteUkExchanger.Convert();

                        //facilities.AddRange(rolesFacility);
                        if (rolesFacilities.ContainsKey(item.Value.AppliedRoles))
                        {
                            rolesFacilities[item.Value.AppliedRoles].AddRange(rolesFacility);
                        }
                        else
                        {
                            rolesFacilities.Add(item.Value.AppliedRoles, rolesFacility);
                        }

                    }
                    var fedFacilities =
                        rolesFacilities.OrderByDescending(d => d.Key.HasFlag(RoleFilter.Architectural))
                            .SelectMany(p => p.Value)
                            .ToList(); //pull architectural roles facilities to the top
                    //fedFacilities = RolesFacilities.Values.SelectMany(f => f).OrderByDescending(f => f.AssetTypes.Count).ToList(); //pull facility with largest number of AssetTypes to the top
                    //fedFacilities = RolesFacilities.Values.SelectMany(f => f).ToList(); //flatten value lists
                    if (fedFacilities.Any())
                    {
                        var baseFacility = fedFacilities.First();
                        fedFacilities.RemoveAt(0);
                        if (parameters.Log)
                        {
                            var logfile = Path.ChangeExtension(parameters.ModelFile, "merge.log");
                            using (var sw = new StreamWriter(logfile))
                                //using (StreamWriter sw = new StreamWriter(Console.OpenStandardOutput())) //to debug console **slow**
                            {
                                sw.AutoFlush = true;
                                foreach (var mergeFacility in fedFacilities)
                                {
                                    baseFacility.Merge(mergeFacility, sw);
                                }
                            }
                        }
                        else
                        {
                            foreach (var mergeFacility in fedFacilities)
                            {
                                baseFacility.Merge(mergeFacility, null);
                            }
                        }
                        facilities.Add(baseFacility);
                    }

                }
                else
                {
                    throw new XbimException("Model is not Federated:");
                }

            }
            catch (ArgumentException Ex) //bad paths etc..
            {
                Worker.ReportProgress(0, Ex.Message);
            }
            catch (XbimException Ex) //not federated
            {
                Worker.ReportProgress(0, Ex.Message);
            }

            return facilities;
        }
예제 #7
0
        /// <summary>
        /// Create XLS file from ifc/xbim files
        /// </summary>
        /// <param name="parameters">Params</param>
        private string GenerateFile(Params parameters)
        {
            string fileName = string.Empty;
            string exportType = parameters.ExportType.ToString();
            //string fileExt = Path.GetExtension(parameters.ModelFile);
            Stopwatch timer = new Stopwatch();
            timer.Start();

            var facilities = GenerateFacility(parameters);
            timer.Stop();
            Worker.ReportProgress(0, string.Format("Time to generate COBieLite data = {0} seconds", timer.Elapsed.TotalSeconds.ToString("F3")));
            timer.Reset();
            timer.Start();
            int index = 1;
            foreach (var facilityType in facilities)
            {
                fileName = Path.GetFileNameWithoutExtension(parameters.ModelFile) + ((facilities.Count == 1) ? "" : "(" + index.ToString() + ")");
                string path = Path.GetDirectoryName(parameters.ModelFile);
                fileName = Path.Combine(path, fileName);
                if (parameters.Log)
                {
                    string logFile = Path.ChangeExtension(fileName, ".log");
                    Worker.ReportProgress(0, string.Format("Creating validation log file: {0}", logFile));
                    using (var log = File.CreateText(logFile))
                    {
                        facilityType.ValidateUK2012(log, false);
                    }
                }
                if ((exportType.Equals("XLS", StringComparison.OrdinalIgnoreCase)) || (exportType.Equals("XLSX", StringComparison.OrdinalIgnoreCase)))
                {
                    fileName =  CreateExcelFile(parameters, fileName, facilityType);
                }
                else if (exportType.Equals("JSON", StringComparison.OrdinalIgnoreCase))
                {
                    fileName = CreateJsonFile(parameters, fileName, facilityType);
                }
                else if (exportType.Equals("XML", StringComparison.OrdinalIgnoreCase))
                {
                    fileName = CreateXmlFile(parameters, fileName, facilityType);
                }
                else if (exportType.Equals("IFC", StringComparison.OrdinalIgnoreCase))
                {
                    fileName = CreateIfcFile(parameters, fileName, facilityType);
                }
                index++;
            }
            timer.Stop();
            Worker.ReportProgress(0, string.Format("Time to generate = {0} seconds", timer.Elapsed.TotalSeconds.ToString("F3")));

            Worker.ReportProgress(0, "Finished COBie Generation");
            return fileName;
        }
예제 #8
0
        /// <summary>
        /// Generate the Facilities held within the Model
        /// </summary>
        /// <param name="parameters">Params</param>
        /// <returns>List of Facilities</returns>
        private List<Facility> GenerateFacility(Params parameters)
        {
            string fileExt = Path.GetExtension(parameters.ModelFile);

            //chsck if federated
            if (fileExt.Equals(".xbimf", StringComparison.OrdinalIgnoreCase))
            {
                return GenerateFedFacility(parameters);
            }
            if ((fileExt.Equals(".xls", StringComparison.OrdinalIgnoreCase)) || (fileExt.Equals(".xlsx", StringComparison.OrdinalIgnoreCase)))
            {
                return GeneratelExcelFacility(parameters);
            }
            if (fileExt.Equals(".json", StringComparison.OrdinalIgnoreCase))
            {
                return GeneratelJsonFacility(parameters);
            }
            if (fileExt.Equals(".xml", StringComparison.OrdinalIgnoreCase))
            {
                return GeneratelXmlFacility(parameters);
            }

            //not Federated
            return GenerateFileFacility(parameters, fileExt);
        }
예제 #9
0
 /// <summary>
 /// Generate a XML File
 /// </summary>
 /// <param name="parameters">Params</param>
 /// <param name="fileName">Root file name</param>
 /// <param name="facility">Facility</param>
 /// <returns>file name</returns>
 private string CreateXmlFile(Params parameters, string fileName, Facility facility)
 {
     var xmlName = Path.ChangeExtension(fileName, ".xml");
     Worker.ReportProgress(0, string.Format("Creating file: {0}", xmlName));
     facility.ReportProgress.Progress = Worker.ReportProgress;
     facility.WriteXml(xmlName, true);
     return xmlName;
 }
예제 #10
0
 /// <summary>
 /// Generate a JSON File
 /// </summary>
 /// <param name="parameters">Params</param>
 /// <param name="fileName">Root file name</param>
 /// <param name="facility">Facility</param>
 /// <returns>file name</returns>
 private string CreateJsonFile(Params parameters, string fileName, Facility facility)
 {
     var jsonName = Path.ChangeExtension(fileName, ".json");
     Worker.ReportProgress(0, string.Format("Creating file: {0}", jsonName));
     facility.ReportProgress.Progress = Worker.ReportProgress;
     facility.WriteJson(jsonName, true);
     return jsonName;
 }
예제 #11
0
        private string CreateIfcFile(Params parameters, string fileName, Facility facility)
        {
            var ifcName = Path.ChangeExtension(fileName, ".ifc");
            if (File.Exists(ifcName))
            {
                DateTime now = DateTime.Now;
                ifcName = Path.GetDirectoryName(ifcName)+ "\\" + Path.GetFileNameWithoutExtension(ifcName) + "(" + DateTime.Now.ToString("HH-mm-ss") + ").ifc";
            }
            var xbimFile = Path.ChangeExtension(ifcName, "xbim");
            Worker.ReportProgress(0, string.Format("Creating file: {0}", xbimFile));
            facility.ReportProgress.Progress = Worker.ReportProgress;
            using (var ifcModel = XbimModel.CreateModel(xbimFile))
            {
                System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
                FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
                ifcModel.Initialise(fvi.CompanyName, fvi.CompanyName, fvi.ProductName, fvi.CompanyName, fvi.ProductVersion);
                ifcModel.ReloadModelFactors();
                using (var txn = ifcModel.BeginTransaction("Convert from COBieLiteUK"))
                {
                    var coBieLiteUkToIfcExchanger = new CoBieLiteUkToIfcExchanger(facility, ifcModel);
                    coBieLiteUkToIfcExchanger.Convert();
                    txn.Commit();
                }
                Worker.ReportProgress(0, string.Format("Creating file: {0}", ifcName));
                ifcModel.SaveAs(ifcName, XbimStorageType.IFC);
                ifcModel.Close();
            }

            return ifcName;
        }
예제 #12
0
 /// <summary>
 /// Generate a Excel File
 /// </summary>
 /// <param name="parameters">Params</param>
 /// <param name="fileName">Root file name</param>
 /// <param name="facility">Facility</param>
 /// <returns>file name</returns>
 private string CreateExcelFile(Params parameters, string fileName, Facility facility)
 {
     ExcelTypeEnum excelType = (ExcelTypeEnum)Enum.Parse(typeof(ExcelTypeEnum), parameters.ExportType.ToString(),true);
     var excelName = Path.ChangeExtension(fileName, excelType == ExcelTypeEnum.XLS ? ".xls" : ".xlsx");
     Worker.ReportProgress(0, string.Format("Creating file: {0}", excelName));
     string msg;
     using (var file = File.Create(excelName))
     {
         facility.ReportProgress.Progress = Worker.ReportProgress;
         facility.WriteCobie(file, excelType, out msg, parameters.Filter, parameters.TemplateFile, true);
     }
     //_worker.ReportProgress(0, msg); //removed for now, kill app for some reason
     return excelName;
 }