/// <summary>
/// Values for deflection read from config files
/// </summary>
/// <param name="oneMillimetre"></param>
/// <param name="geometryObject"></param>
/// <param name="precision"></param>
/// <param name="logger"></param>
/// <returns></returns>
public XbimShapeGeometry CreateShapeGeometry(double oneMillimetre, IXbimGeometryObject geometryObject, double precision, ILogger logger)
{
using (new Tracer(LogHelper.CurrentFunctionName(), this._logger, geometryObject))
{
return(_engine.CreateShapeGeometry(oneMillimetre, geometryObject, precision, logger));
}
}
/// <summary>
/// Transforms an object geomtrically and returns a new object
/// </summary>
/// <param name="geometry"></param>
/// <param name="cartesianTransform"></param>
/// <returns></returns>
public IXbimGeometryObject Transformed(IXbimGeometryObject geometry, IIfcCartesianTransformationOperator cartesianTransform)
{
using (new Tracer(LogHelper.CurrentFunctionName(), this._logger, geometry))
{
return(_engine.Transformed(geometry, cartesianTransform));
}
}
public void WriteTriangulation(BinaryWriter bw, IXbimGeometryObject shape, double tolerance, double deflection, double angle)
{
using (new Tracer(LogHelper.CurrentFunctionName(), this._logger, shape))
{
_engine.WriteTriangulation(bw, shape, tolerance, deflection, angle);
}
}
public IXbimGeometryObject Moved(IXbimGeometryObject geometryObject, IIfcAxis2Placement2D placement)
{
using (new Tracer(LogHelper.CurrentFunctionName(), this._logger, geometryObject))
{
return(_engine.Moved(geometryObject, placement));
}
}
public IXbimGeometryObject Moved(IXbimGeometryObject geometryObject, IIfcObjectPlacement objectPlacement, ILogger logger)
{
using (new Tracer(LogHelper.CurrentFunctionName(), this._logger, geometryObject))
{
return(_engine.Moved(geometryObject, objectPlacement, logger));
}
}
public string ToBrep(IXbimGeometryObject geometryObject)
{
using (new Tracer(LogHelper.CurrentFunctionName(), this._logger, geometryObject))
{
return(_engine.ToBrep(geometryObject));
}
}
public XbimShapeGeometry CreateShapeGeometry(IXbimGeometryObject geometryObject, double precision, double deflection, ILogger logger /*, angle = 0.5*/)
{
using (new Tracer(LogHelper.CurrentFunctionName(), this._logger, geometryObject))
{
return(_engine.CreateShapeGeometry(geometryObject, precision, deflection, 0.5, XbimGeometryType.Polyhedron, logger));
}
}
public void Mesh(IXbimMeshReceiver receiver, IXbimGeometryObject geometryObject, double precision, double deflection,
double angle = 0.5)
{
using (new Tracer(LogHelper.CurrentFunctionName(), this._logger, geometryObject))
{
_engine.Mesh(receiver, geometryObject, precision, deflection, angle);
}
}
public XbimShapeGeometry CreateShapeGeometry(IXbimGeometryObject geometryObject, double precision, double deflection,
double angle, XbimGeometryType storageType, ILogger logger)
{
using (new Tracer(LogHelper.CurrentFunctionName(), this._logger, geometryObject))
{
return(_engine.CreateShapeGeometry(geometryObject, precision, deflection, angle, storageType, logger));
}
}
public void WireInitFromIfcIndexedPolyCurveTest()
{
using (var model = MemoryModel.OpenRead(@"Ifc4TestFiles\WirePolycurve.ifc"))
{
var shape = model.Instances[185] as IIfcGeometricRepresentationItem;
IXbimGeometryObject geomObject = geomEngine.Create(shape);
Assert.IsTrue(geomObject.IsValid);
}
}
public Tracer(string methodName, ILogger logger, IXbimGeometryObject geometryObject)
{
this.methodName = methodName;
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
if (logger.IsEnabled(LogLevel.Trace)) // Optimisation to avoid GetType reflection unless Trace enabled
{
logger.LogTrace("Entering GeometryEngine {function} with {tag} [{type}]",
methodName, geometryObject.Tag, geometryObject.GetType().Name);
}
}
public void ReadWriteTriangulationOfNonPlanarSolidTest()
{
using (var m = XbimModel.CreateTemporaryModel())
{
using (var txn = m.BeginTransaction())
{
var profile = IfcModelBuilder.MakeCircleHollowProfileDef(m, 20, 1);
var extrude = IfcModelBuilder.MakeExtrudedAreaSolid(m, profile, 40);
var solid = XbimGeometryCreator.CreateSolid(extrude);
TextWriter tw = new StringWriter();
XbimGeometryCreator.WriteTriangulation(tw, solid, m.ModelFactors.Precision, m.ModelFactors.DeflectionTolerance, 0.5);
TextReader tr = new StringReader(tw.ToString());
IXbimGeometryObject geom = XbimGeometryCreator.ReadTriangulation(tr);
var triangulatedSold = geom as IXbimSolid;
Assert.IsNotNull(triangulatedSold, "Invalid solid returned");
Assert.IsTrue(Math.Abs(solid.Volume - triangulatedSold.Volume) < 5, "Volume differs too much");
}
}
}
public IXbimGeometryObject Moved(IXbimGeometryObject geometryObject, IIfcObjectPlacement objectPlacement)
{
return(_engine.Moved(geometryObject, objectPlacement));
}
public string ToBrep(IXbimGeometryObject geometryObject)
{
return(_engine.ToBrep(geometryObject));
}
public XbimShapeGeometry CreateShapeGeometry(IXbimGeometryObject geometryObject, double precision, double deflection, double angle)
{
return(_engine.CreateShapeGeometry(geometryObject, precision, deflection, angle, XbimGeometryType.Polyhedron));
}
public void WriteBrep(string filename, IXbimGeometryObject geomObj)
{
// no logger is provided so no tracing is started for this function
_engine.WriteBrep(filename, geomObj);
}
public void WriteTriangulation(BinaryWriter bw, IXbimGeometryObject shape, double tolerance, double deflection)
{
WriteTriangulation(bw, shape, tolerance, deflection: deflection, angle: 0.5);
}
public void TestCuttingOpenings()
{
// var w = new XbimOccWriter();
const string modelDirectory = "";//define where your files to test are @"D:\Users\steve\xBIM\Test Models\Use Cases\Live";
if (string.IsNullOrWhiteSpace(modelDirectory))
{
Trace.WriteLine("TestCuttingOpenings tests skipped. Enter a directory where the test models can be found");
return;
}
var di = new DirectoryInfo(modelDirectory);
FileInfo[] toProcess = di.GetFiles("*.IFC", SearchOption.TopDirectoryOnly);
foreach (var file in toProcess)
{
using (var m = new XbimModel())
{
m.CreateFrom(file.FullName, null, null, true, true);
using (var eventTrace = LoggerFactory.CreateEventTrace())
{
var theElements = _xbimGeometryCreator.CreateSolidSet();
var openings = m.Instances.OfType <IfcRelVoidsElement>()
.Where(
r =>
r.RelatingBuildingElement.Representation != null &&
r.RelatedOpeningElement.Representation != null)
.Select(
f =>
new
{
element = f.RelatingBuildingElement,
feature = f.RelatedOpeningElement
});
var toCut = openings.GroupBy(x => x.element, y => y.feature).ToList();
Parallel.ForEach(toCut, new ParallelOptions(), rel =>
// foreach (var rel in toCut)
{
var elem = rel.Key;
var elemTransform = elem.Transform();
var elemSolids = _xbimGeometryCreator.CreateSolidSet();
foreach (var rep in elem.Representation.Representations)
{
if (rep.ContextOfItems.ContextType != null &&
"Model" == rep.ContextOfItems.ContextType.Value.ToString() && (rep.RepresentationIdentifier.HasValue && rep.RepresentationIdentifier == "Body"))
{
foreach (var item in rep.Items.OfType <IfcGeometricRepresentationItem>())
{
IXbimGeometryObject shape = _xbimGeometryCreator.Create(item);
if (!shape.IsValid)
{
Assert.IsTrue(shape.IsValid, "Invalid shape found in #" + item.EntityLabel);
}
var solid = shape as IXbimSolid;
if (solid != null)
{
IfcCsgTests.GeneralTest(solid, true, item is IfcHalfSpaceSolid,
rep.EntityLabel);
solid = (IXbimSolid)solid.Transform(elemTransform);
elemSolids.Add(solid);
}
else if (shape is IXbimSolidSet)
{
foreach (var subSolid in shape as IXbimSolidSet)
{
IfcCsgTests.GeneralTest(subSolid, true, item is IfcHalfSpaceSolid,
rep.EntityLabel);
elemSolids.Add(subSolid.Transform(elemTransform));
}
}
else if (shape is IXbimGeometryObjectSet)
{
foreach (var subShape in shape as IXbimGeometryObjectSet)
{
if (subShape is IXbimSolid)
{
IfcCsgTests.GeneralTest((IXbimSolid)subShape, true,
item is IfcHalfSpaceSolid,
rep.EntityLabel);
}
elemSolids.Add(subShape.Transform(elemTransform));
}
}
else
{
Trace.WriteLine("No Solid found #" + item.EntityLabel + " " +
shape.GetType().Name);
}
}
}
}
var openingSolids = _xbimGeometryCreator.CreateSolidSet();
foreach (var opening in rel)
{
var openingTransform = opening.Transform();
foreach (var openingrep in opening.Representation.Representations)
{
if (openingrep.ContextOfItems.ContextType != null &&
"Model" == openingrep.ContextOfItems.ContextType.Value.ToString() && (openingrep.RepresentationIdentifier.HasValue && openingrep.RepresentationIdentifier == "Body"))
{
foreach (
var openingitem in openingrep.Items.OfType <IfcGeometricRepresentationItem>()
)
{
IXbimGeometryObject openingshape = _xbimGeometryCreator.Create(openingitem);
if (!openingshape.IsValid)
{
Trace.WriteLine("Invalid shape found in #" + openingitem.EntityLabel);
continue;
}
var openingsolid = openingshape as IXbimSolid;
if (openingsolid != null)
{
IfcCsgTests.GeneralTest((IXbimSolid)openingshape, true,
openingitem is IfcHalfSpaceSolid,
openingrep.EntityLabel);
openingsolid = (IXbimSolid)openingsolid.Transform(openingTransform);
openingSolids.Add(openingsolid);
}
else if (openingshape is IXbimSolidSet)
{
foreach (var subOpeningSolid in openingshape as IXbimSolidSet)
{
IfcCsgTests.GeneralTest(subOpeningSolid, true,
openingitem is IfcHalfSpaceSolid,
openingrep.EntityLabel);
openingSolids.Add(subOpeningSolid.Transform(openingTransform));
}
}
else if (openingshape is IXbimGeometryObjectSet)
{
foreach (var subShape in openingshape as IXbimGeometryObjectSet)
{
if (subShape is IXbimSolid)
{
IfcCsgTests.GeneralTest((IXbimSolid)subShape, true,
openingitem is IfcHalfSpaceSolid,
openingrep.EntityLabel);
}
openingSolids.Add(subShape.Transform(openingTransform));
}
}
else
{
Trace.WriteLine("No Solid found #" + openingitem.EntityLabel + " " +
openingshape.GetType().Name);
}
}
}
}
}
// ReSharper disable once AccessToDisposedClosure
var solidResult = elemSolids.Cut(openingSolids, m.ModelFactors.PrecisionBoolean);
foreach (var result in solidResult)
{
IfcCsgTests.GeneralTest(result, true, false,
elem.EntityLabel);
theElements.Add(result);
}
}
);
// w.Write(theElements, "d:\\xbim\\r");
if (eventTrace.Events.Count > 0)
{
//var assertNow = false;
Trace.WriteLine("Model: " + file.Name);
foreach (var err in eventTrace.Events)
{
Trace.WriteLine(err.Message);
//if (err.EventLevel == EventLevel.ERROR)
// assertNow = true;
}
// Assert.IsTrue(assertNow == false, "Error events were raised");
}
}
}
}
}
public void WriteTriangulation(BinaryWriter bw, IXbimGeometryObject shape, double tolerance, double deflection, double angle)
{
_engine.WriteTriangulation(bw, shape, tolerance, deflection, angle);
}
public IXbimShapeGeometryData Mesh(IXbimGeometryObject geomObject)
{
return new XbimShapeGeometry();
}
public IXbimShapeGeometryData CreateShapeGeometry(IXbimGeometryObject geometryObject, double precision, double deflection,
double angle, XbimGeometryType storageType)
{
return(_engine.CreateShapeGeometry(geometryObject, precision, deflection, angle, storageType));
}
public IXbimShapeGeometryData CreateShapeGeometry(IXbimGeometryObject geometryObject, double precision, double deflection /*, angle = 0.5*/)
{
return(_engine.CreateShapeGeometry(geometryObject, precision, deflection, 0.5, XbimGeometryType.Polyhedron));
}
/// <summary>
/// Transforms an object geomtrically and returns a new object
/// </summary>
/// <param name="geometry"></param>
/// <param name="cartesianTransform"></param>
/// <returns></returns>
public IXbimGeometryObject Transformed(IXbimGeometryObject geometry, IIfcCartesianTransformationOperator cartesianTransform)
{
return(_engine.Transformed(geometry, cartesianTransform));
}
public IXbimShapeGeometryData CreateShapeGeometry(IXbimGeometryObject geometryObject, double precision, double deflection,
double angle, XbimGeometryType storageType)
{
return _engine.CreateShapeGeometry(geometryObject, precision, deflection, angle, storageType);
}
public void WriteTriangulation(BinaryWriter bw, IXbimGeometryObject shape, double tolerance, double deflection)
{
WriteTriangulation(bw, shape, tolerance, deflection: deflection, angle: 0.5);
}
public IXbimGeometryObject Moved(IXbimGeometryObject geometryObject, IIfcAxis2Placement2D placement)
{
return(_engine.Moved(geometryObject, placement));
}
// TODO: Stubbed until we merge https://github.com/xBimTeam/XbimGeometry/commit/86bc1e83eeed0fd84b33bf64045cb6afeac3807b#diff-569f41af2079f5a015416a3c37bb6a5a1b81c5f97b33a341d506634abbfbe52b
public XbimShapeGeometry CreateShapeGeometry(double oneMillimetre, IXbimGeometryObject geometryObject, double precision, ILogger logger = null)
{
throw new NotImplementedException();
}
public IXbimShapeGeometryData Mesh(IXbimGeometryObject geomObject)
{
return(new XbimShapeGeometry());
}
public IXbimShapeGeometryData CreateShapeGeometry(IXbimGeometryObject geometryObject, double precision, double deflection /*, angle = 0.5*/)
{
return _engine.CreateShapeGeometry(geometryObject, precision, deflection, 0.5, XbimGeometryType.Polyhedron);
}
public void WriteTriangulation(BinaryWriter bw, IXbimGeometryObject shape, double tolerance, double deflection, double angle)
{
_engine.WriteTriangulation(bw, shape, tolerance, deflection, angle);
}
public void Mesh(IXbimMeshReceiver receiver, IXbimGeometryObject geometryObject, double precision, double deflection,
double angle = 0.5)
{
_engine.Mesh(receiver, geometryObject, precision, deflection, angle);
}
