private ProcessResult ProcessFile(string ifcFile, StreamWriter writer)
{
RemoveFiles(ifcFile);
long geomTime = -1; long sceneTime = -1; long parseTime = -1;
using (EventTrace eventTrace = LoggerFactory.CreateEventTrace())
{
ProcessResult result = new ProcessResult() { Errors = -1 };
try
{
Stopwatch watch = new Stopwatch();
watch.Start();
using (XbimModel model = ParseModelFile(ifcFile,Params.Caching))
{
parseTime = watch.ElapsedMilliseconds;
string xbimFilename = BuildFileName(ifcFile, ".xbim");
//model.Open(xbimFilename, XbimDBAccess.ReadWrite);
XbimMesher.GenerateGeometry(model, Logger, null);
geomTime = watch.ElapsedMilliseconds - parseTime;
XbimSceneBuilder sb = new XbimSceneBuilder();
string xbimSceneName = BuildFileName(ifcFile, ".xbimScene");
sb.BuildGlobalScene(model, xbimSceneName);
sceneTime = watch.ElapsedMilliseconds - geomTime;
IIfcFileHeader header = model.Header;
watch.Stop();
IfcOwnerHistory ohs = model.Instances.OfType<IfcOwnerHistory>().FirstOrDefault();
result = new ProcessResult()
{
ParseDuration = parseTime,
GeometryDuration = geomTime,
SceneDuration = sceneTime,
FileName = ifcFile,
Entities = model.Instances.Count,
IfcSchema = header.FileSchema.Schemas.FirstOrDefault(),
IfcDescription = String.Format("{0}, {1}", header.FileDescription.Description.FirstOrDefault(), header.FileDescription.ImplementationLevel),
GeometryEntries = model.GeometriesCount,
IfcLength = ReadFileLength(ifcFile),
XbimLength = ReadFileLength(xbimFilename),
SceneLength = ReadFileLength(xbimSceneName),
IfcProductEntries = model.Instances.CountOf<IfcProduct>(),
IfcSolidGeometries = model.Instances.CountOf<IfcSolidModel>(),
IfcMappedGeometries = model.Instances.CountOf<IfcMappedItem>(),
BooleanGeometries = model.Instances.CountOf<IfcBooleanResult>(),
Application = ohs == null ? "Unknown" : ohs.OwningApplication.ToString(),
};
model.Close();
}
}
catch (Exception ex)
{
Logger.Error(String.Format("Problem converting file: {0}", ifcFile), ex);
result.Failed = true;
}
finally
{
result.Errors = (from e in eventTrace.Events
where (e.EventLevel == EventLevel.ERROR)
select e).Count();
result.Warnings = (from e in eventTrace.Events
where (e.EventLevel == EventLevel.WARN)
select e).Count();
result.FileName = ifcFile;
if (eventTrace.Events.Count > 0)
{
CreateLogFile(ifcFile, eventTrace.Events);
}
lock (thisLock)
{
writer.WriteLine(result.ToCsv());
writer.Flush();
}
}
return result;
}
}
static int Main(string[] args)
{
int totErrors = 0;
// We need to use the logger early to initialise before we use EventTrace
Logger.Debug("XbimConvert starting...");
arguments = Params.ParseParams(args);
if (!arguments.IsValid)
{
return -1;
}
var SubMode = SearchOption.TopDirectoryOnly;
if (arguments.ProcessSubDir)
SubMode = SearchOption.AllDirectories;
var files = Directory.GetFiles(arguments.specdir, arguments.specpart, SubMode);
if (files.Length == 0)
{
Console.WriteLine("Invalid IFC filename or filter: {0}, current directory is: {1}", args[0], Directory.GetCurrentDirectory());
return -1;
}
long parseTime = 0;
long geomTime = 0;
foreach (var origFileName in files)
{
using (EventTrace eventTrace = LoggerFactory.CreateEventTrace())
{
try
{
Console.WriteLine("Starting conversion of {0}", origFileName);
Logger.InfoFormat("Starting conversion of {0}", origFileName);
string xbimFileName = BuildFileName(origFileName, ".xbim");
//string xbimGeometryFileName = BuildFileName(arguments.IfcFileName, ".xbimGC");
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
ReportProgressDelegate progDelegate = delegate(int percentProgress, object userState)
{
if (!arguments.IsQuiet)
{
Console.Write(string.Format("{0:D5} Converted", percentProgress));
ResetCursor(Console.CursorTop);
}
};
watch.Start();
using (XbimModel model = ParseModelFile(origFileName, xbimFileName, arguments.Caching))
{
//model.Open(xbimFileName, XbimDBAccess.ReadWrite);
parseTime = watch.ElapsedMilliseconds;
if (!arguments.NoGeometry)
{
XbimMesher.GenerateGeometry(model, Logger, progDelegate);
geomTime = watch.ElapsedMilliseconds - parseTime;
if (arguments.GenerateScene)
{
Stopwatch sceneTimer = new Stopwatch();
if (!arguments.IsQuiet)
Console.Write("Scene generation started...");
sceneTimer.Start();
XbimSceneBuilder sb = new XbimSceneBuilder();
sb.Options = arguments.GenerateSceneOptions;
string xbimSceneName = BuildFileName(xbimFileName, ".xbimScene");
sb.BuildGlobalScene(model, xbimSceneName,
!arguments.IsQuiet ? Logger : null
);
sceneTimer.Stop();
if (!arguments.IsQuiet)
Console.WriteLine(string.Format(" Completed in {0} ms", sceneTimer.ElapsedMilliseconds));
}
}
model.Close();
watch.Stop();
}
// XbimModel.Terminate();
GC.Collect();
ResetCursor(Console.CursorTop + 1);
Console.WriteLine("Success. Parsed in " + parseTime + " ms, geometry meshed in " + geomTime + " ms, total time " + (parseTime+geomTime) + " ms.");
}
catch (Exception e)
{
if (e is XbimException || e is NotImplementedException)
{
// Errors we have already handled or know about. Keep details brief in the log
Logger.ErrorFormat("One or more errors converting {0}. Exiting...", origFileName);
CreateLogFile(origFileName, eventTrace.Events);
DisplayError(string.Format("One or more errors converting {0}, {1}", origFileName, e.Message));
}
else
{
// Unexpected failures. Log exception details
Logger.Fatal(String.Format("Fatal Error converting {0}. Exiting...", origFileName), e);
CreateLogFile(origFileName, eventTrace.Events);
DisplayError(string.Format("Fatal Error converting {0}, {1}", origFileName, e.Message));
}
}
int errors = (from e in eventTrace.Events
where (e.EventLevel > EventLevel.INFO)
select e).Count();
if (errors > 0)
{
CreateLogFile(origFileName, eventTrace.Events);
}
totErrors += errors;
}
}
GetInput();
Logger.Info("XbimConvert finished successfully...");
return totErrors;
}