/// <summary>
/// Create XLS file from ifc/xbim files
/// </summary>
/// <param name="parameters">Params</param>
private IEnumerable <string> GenerateFile(CobieConversionParams parameters)
{
var ret = new List <string>();
var path = Path.GetDirectoryName(parameters.OutputFileName);
var cobieModels = GetCobieModels(parameters);
var index = 1;
foreach (var facilityType in cobieModels)
{
var bareFileName = Path.GetFileNameWithoutExtension(parameters.OutputFileName);
if (cobieModels.Count > 1)
{
bareFileName += "(" + index + ")";
}
Worker.ReportProgress(0, string.Format("Beginning facility '{0}'", bareFileName));
var timer = new Stopwatch();
timer.Start();
var fullFileName = Path.Combine(path, bareFileName);
switch (parameters.ExportFormat)
{
case ExportFormatEnum.XLS:
case ExportFormatEnum.XLSX:
string report = string.Empty;
fullFileName = CreateExcelFile(fullFileName, parameters, facilityType, out report);
if (!String.IsNullOrEmpty(report) && parameters.Log)
{
var logFile = Path.ChangeExtension(fullFileName, ".validation.log");
Worker.ReportProgress(0, string.Format("Creating validation log file: {0}", logFile));
File.WriteAllText(logFile, report);
}
break;
case ExportFormatEnum.STEP21:
fullFileName = CreateStepFile(fullFileName, parameters, facilityType);
break;
case ExportFormatEnum.JSON:
//break;
case ExportFormatEnum.XML:
//break;
case ExportFormatEnum.IFC:
default:
throw new NotImplementedException(String.Format("COBie Express does not currently support {0}", parameters.ExportFormat));
//break;
}
index++;
timer.Stop();
Worker.ReportProgress(0, string.Format("Time to save: {0} seconds", timer.Elapsed.TotalSeconds.ToString("F3")));
ret.Add(fullFileName);
}
Worker.ReportProgress(0, "Finished COBie Generation");
return(ret);
}
private void DoExport(object sender, RoutedEventArgs e)
{
btnGenerate.IsEnabled = false;
if (_cobieWorker == null)
{
_cobieWorker = new CobieLiteConverter();
_cobieWorker.Worker.ProgressChanged += WorkerProgressChanged;
_cobieWorker.Worker.RunWorkerCompleted += WorkerCompleted;
}
// get Excel File Type
var excelType = GetExcelType();
var v = new FileInfo(Model.FileName);
var exportFileName = Path.ChangeExtension(Path.Combine(TxtFolderName.Text, v.Name), "tempExtension");
// set parameters
var conversionSettings = new CobieConversionParams
{
Source = Model,
OutputFileName = exportFileName,
TemplateFile = SelectedTemplate,
ExportFormat = excelType,
ExtId = (UseExternalIds.IsChecked != null && UseExternalIds.IsChecked.Value)
? EntityIdentifierMode.IfcEntityLabels
: EntityIdentifierMode.GloballyUniqueIds,
SysMode = SetSystemMode(),
Filter = _assetfilters,
ConfigFile = ConfigFile.FullName,
Log = true
};
// run worker
_cobieWorker.Run(conversionSettings);
}
private IModel GetCobieModel(CobieConversionParams parameters)
{
var timer = new Stopwatch();
timer.Start();
var model = parameters.Source;
if (model is IFederatedModel fm && fm.ReferencedModels.Count() > 1)
{
throw new NotImplementedException("Work to do on COBie Federated");
//see COBieLitConverter for Lite code
}
var cobie = parameters.NewCobieModel();
using (var txn = cobie.BeginTransaction("begin conversion"))
{
var exchanger = new IfcToCoBieExpressExchanger
(model,
cobie,
parameters.ReportProgress,
parameters.Filter,
parameters.ConfigFile,
parameters.ExtId,
parameters.SysMode
);
exchanger.Convert();
txn.Commit();
}
timer.Stop();
parameters.ReportProgress(0, string.Format("Time to generate COBieLite data: {0} seconds", timer.Elapsed.TotalSeconds.ToString("F3")));
return(cobie);
}
private List <CobieModel> GetCobieModels(IfcStore model, CobieConversionParams parameters)
{
List <CobieModel> cobieModels = new List <CobieModel>();
if (model.IsFederation == false)
{
var cobie = new CobieModel();
using (var txn = cobie.BeginTransaction("begin conversion"))
{
var exchanger = new IfcToCoBieExpressExchanger
(model,
cobie,
Worker.ReportProgress,
parameters.Filter,
parameters.ConfigFile,
parameters.ExtId,
parameters.SysMode
);
exchanger.Convert();
cobieModels.Add(cobie);
txn.Commit();
}
}
else
{
throw new NotImplementedException("Work to do on COBie Federated");
//see COBieLitConverter for Lite code
}
return(cobieModels);
}
/// <summary>
/// Generate Facilities for a xbim or ifc type file
/// </summary>
/// <param name="sourceFile"></param>
/// <param name="parameters"></param>
/// <returns></returns>
private List <Facility> GetFacilitiesFromIfcStoreFilename(string sourceFile, CobieConversionParams parameters)
{
using (var model = IfcStore.Open(sourceFile))
{
var facilities = GetFacilities(model, parameters);
return(facilities);
}
}
/// <summary>
/// Generate a Step File
/// </summary>
/// <param name="fileName">Root file name</param>
/// <param name="parameters">Params</param>
/// <param name="cobie"></param>
/// <returns>file name</returns>
private string CreateStepFile(string fileName, CobieConversionParams parameters, CobieModel cobie)
{
//set export file name
var stepName = Path.ChangeExtension(fileName, ".cobie");
cobie.SaveAsStep21(stepName);
return(stepName);
}
/// <summary>
/// Generate a Excel File
/// </summary>
/// <param name="fileName">Root file name</param>
/// <param name="parameters">Params</param>
/// <param name="cobie"></param>
/// <param name="report"></param>
/// <returns>file name</returns>
private string CreateExcelFile(string fileName, CobieConversionParams parameters, CobieModel cobie, out string report)
{
//set export file name
var excelType = (ExcelTypeEnum)Enum.Parse(typeof(ExcelTypeEnum), parameters.ExportFormat.ToString(), true);
var excelName = Path.ChangeExtension(fileName, excelType == ExcelTypeEnum.XLS ? ".xls" : ".xlsx");
cobie.ExportToTable(excelName, out report);
return(excelName);
}
/// <summary>
/// Run the worker
/// </summary>
/// <param name="args"></param>
public async Task <IModel> Run(CobieConversionParams args)
{
if (args.ReportProgress == null)
{
args.ReportProgress = (int percentProgress, object userState) => { }
}
;
return(await Task.Run <IModel>(() => {
return GetCobieModel(args);
}));
}
/// <summary>
/// Generate a Excel File
/// </summary>
/// <param name="fileName">Root file name</param>
/// <param name="parameters">Params</param>
/// <param name="facility">Facility</param>
/// <returns>file name</returns>
private string CreateExcelFile(string fileName, CobieConversionParams parameters, Facility facility)
{
var excelType = (ExcelTypeEnum)Enum.Parse(typeof(ExcelTypeEnum), parameters.ExportFormat.ToString(), true);
var excelName = Path.ChangeExtension(fileName, excelType == ExcelTypeEnum.XLS ? ".xls" : ".xlsx");
// Worker.ReportProgress(0, string.Format("Creating file: {0}", excelName));
using (var file = File.Create(excelName))
{
facility.ReportProgress.Progress = Worker.ReportProgress;
string msg;
facility.WriteCobie(file, excelType, out msg, parameters.Filter, parameters.TemplateFile);
}
//_worker.ReportProgress(0, msg); //removed for now, kill app for some reason
return(excelName);
}
private List <Facility> GetFacilities(CobieConversionParams parameters)
{
List <Facility> ret = null;
var timer = new Stopwatch();
timer.Start();
if (parameters.Source is string)
{
var sourceFile = (string)parameters.Source;
if (!File.Exists(sourceFile))
{
string message = string.Format("Source file not found {0}", sourceFile);
Worker.ReportProgress(0, message);
Logger.Error(message);
return(null);
}
var fileExt = Path.GetExtension(sourceFile);
switch (fileExt.ToLowerInvariant())
{
case ".xls":
case ".xlsx":
ret = GetFacilitiesFromExcelFilename(sourceFile, parameters.TemplateFile);
break;
case ".json":
ret = GetFacilitiesFromJsonFilename(sourceFile);
break;
case ".xml":
ret = GetFacilitiesFromXmlFilename(sourceFile);
break;
default:
ret = GetFacilitiesFromIfcStoreFilename(sourceFile, parameters);
break;
}
}
else if (parameters.Source is IfcStore)
{
ret = GetFacilities((IfcStore)parameters.Source, parameters);
}
timer.Stop();
Worker.ReportProgress(0, string.Format("Time to generate COBieLite data: {0} seconds", timer.Elapsed.TotalSeconds.ToString("F3")));
return(ret);
}
/// <summary>
/// Create XLS file from ifc/xbim files
/// </summary>
/// <param name="parameters">Params</param>
private IEnumerable <string> GenerateFile(CobieConversionParams parameters)
{
var ret = new List <string>();
var path = Path.GetDirectoryName(parameters.OutputFileName);
Debug.Assert(path != null);
var facilities = GetFacilities(parameters);
var index = 1;
foreach (var facilityType in facilities)
{
var bareFileName = Path.GetFileNameWithoutExtension(parameters.OutputFileName);
if (facilities.Count > 1)
{
bareFileName += "(" + index + ")";
}
Worker.ReportProgress(0, string.Format("Beginning facility '{0}'", bareFileName));
var timer = new Stopwatch();
timer.Start();
var fullFileName = Path.Combine(path, bareFileName);
if (parameters.Log)
{
var logFile = Path.ChangeExtension(fullFileName, ".validation.log");
Worker.ReportProgress(0, string.Format("Creating validation log file: {0}", logFile));
using (var log = File.CreateText(logFile))
{
facilityType.ValidateUK2012(log, false);
}
Worker.ReportProgress(0, string.Format("Time to validate: {0} seconds", timer.Elapsed.TotalSeconds.ToString("F3")));
timer.Restart();
}
switch (parameters.ExportFormat)
{
case ExportFormatEnum.XLS:
case ExportFormatEnum.XLSX:
fullFileName = CreateExcelFile(fullFileName, parameters, facilityType);
break;
case ExportFormatEnum.JSON:
fullFileName = CreateJsonFile(fullFileName, facilityType);
break;
case ExportFormatEnum.XML:
fullFileName = CreateXmlFile(fullFileName, facilityType);
break;
case ExportFormatEnum.STEP21:
throw new NotSupportedException("COBie lite does not have a STEP21 option");
case ExportFormatEnum.IFC:
default:
fullFileName = CreateIfcFile(fullFileName, facilityType);
break;
}
index++;
timer.Stop();
Worker.ReportProgress(0, string.Format("Time to save: {0} seconds", timer.Elapsed.TotalSeconds.ToString("F3")));
ret.Add(fullFileName);
}
Worker.ReportProgress(0, "Finished COBie Generation");
return(ret);
}
/// <summary>
/// Run the worker
/// </summary>
/// <param name="args"></param>
public void Run(CobieConversionParams args)
{
Worker.RunWorkerAsync(args);
}
private List <Facility> GetFacilities(IfcStore model, CobieConversionParams parameters)
{
var facilities = new List <Facility>();
if (model.IsFederation == false)
{
var ifcToCoBieLiteUkExchanger = new IfcToCOBieLiteUkExchanger(
model,
facilities,
Worker.ReportProgress,
parameters.Filter,
parameters.ConfigFile,
parameters.ExtId,
parameters.SysMode
);
facilities = ifcToCoBieLiteUkExchanger.Convert();
}
else
{
var roles = model.GetFederatedFileRoles();
var fedFilters = parameters.Filter.SetFedModelFilter(roles);
var rolesFacilities = new Dictionary <RoleFilter, List <Facility> >();
foreach (var filter in fedFilters)
{
var ifcToCoBieLiteUkExchanger = new IfcToCOBieLiteUkExchanger(
filter.Key.Model,
new List <Facility>(),
Worker.ReportProgress,
filter.Value,
parameters.ConfigFile,
parameters.ExtId,
parameters.SysMode
);
ifcToCoBieLiteUkExchanger.ReportProgress.Progress = Worker.ReportProgress;
var rolesFacility = ifcToCoBieLiteUkExchanger.Convert();
//facilities.AddRange(rolesFacility);
if (rolesFacilities.ContainsKey(filter.Value.AppliedRoles))
{
rolesFacilities[filter.Value.AppliedRoles].AddRange(rolesFacility);
}
else
{
rolesFacilities.Add(filter.Value.AppliedRoles, rolesFacility);
}
}
var fedFacilities =
rolesFacilities.OrderByDescending(d => d.Key.HasFlag(RoleFilter.Architectural))
.SelectMany(p => p.Value)
.ToList();
if (!fedFacilities.Any())
{
return(facilities);
}
var baseFacility = fedFacilities.First();
fedFacilities.RemoveAt(0);
if (parameters.Log)
{
var logfile = Path.ChangeExtension(model.FileName, "merge.log");
using (var sw = new StreamWriter(logfile))
{
sw.AutoFlush = true;
foreach (var mergeFacility in fedFacilities)
{
baseFacility.Merge(mergeFacility, sw);
}
}
}
else
{
foreach (var mergeFacility in fedFacilities)
{
baseFacility.Merge(mergeFacility);
}
}
facilities.Add(baseFacility);
}
return(facilities);
}
/// <summary>
/// On Click Generate Button
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnGenerate_Click(object sender, EventArgs e)
{
if (chkBoxFlipFilter.Checked)
{
// ReSharper disable LocalizableElement
var result = MessageBox.Show(
"Flip Filter is ticked, this will show only excluded items, Do you want to continue",
"Warning", MessageBoxButtons.YesNo);
if (result == DialogResult.No)
{
return;
}
}
btnGenerate.Enabled = false;
//get required type of COBie
COBieType cobieType;
Enum.TryParse <COBieType>(cmBoxCOBieType.SelectedValue.ToString(), out cobieType);
if (cobieType == COBieType.COBieLiteUK)
{
if (_cobieWorker == null || !(_cobieWorker is CobieLiteConverter))
{
_cobieWorker = new CobieLiteConverter();
_cobieWorker.Worker.ProgressChanged += WorkerProgressChanged;
_cobieWorker.Worker.RunWorkerCompleted += WorkerCompleted;
}
}
else if (cobieType == COBieType.COBieExpress)
{
if (_cobieWorker == null || !(_cobieWorker is CobieExpressConverter))
{
_cobieWorker = new CobieExpressConverter();
_cobieWorker.Worker.ProgressChanged += WorkerProgressChanged;
_cobieWorker.Worker.RunWorkerCompleted += WorkerCompleted;
}
}
else
{
throw new ArgumentException("Unknown COBieType requested");
}
//get Excel File Type
var excelType = GetExcelType();
//set filters
var filterRoles = SetRoles();
if (!chkBoxNoFilter.Checked)
{
_assetfilters.ApplyRoleFilters(filterRoles);
_assetfilters.FlipResult = chkBoxFlipFilter.Checked;
}
//set parameters
var conversionSettings = new CobieConversionParams
{
Source = txtPath.Text,
OutputFileName = Path.ChangeExtension(txtPath.Text, "Cobie"),
TemplateFile = txtTemplate.Text,
ExportFormat = excelType,
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(conversionSettings);
}
private List <CobieModel> GetCobieModelsFromIfcStoreFilename(string sourceFile, CobieConversionParams parameters)
{
using (var model = IfcStore.Open(sourceFile))
{
return(GetCobieModels(model, parameters));
}
}
