/// <summary>
/// Return geometry for a particular representation item.
/// </summary>
/// <param name="shapeEditScope">The shape edit scope.</param>
/// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
/// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
/// <param name="guid">The guid of an element for which represntation is being created.</param>
/// <returns>The created geometry.</returns>
protected override IList <GeometryObject> CreateGeometryInternal(
IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
{
// since IFCAdvancedBrep must contain a closed shell, we set the BuildPreferenceType to be solid for now
for (int pass = 0; pass < 2; pass++)
{
using (BuilderScope bs = shapeEditScope.InitializeBuilder(IFCShapeBuilderType.BrepBuilder))
{
BrepBuilderScope brepBuilderScope = bs as BrepBuilderScope;
BRepType brepType = (pass == 0) ? BRepType.Solid : BRepType.OpenShell;
brepBuilderScope.StartCollectingFaceSet(brepType);
Outer.AllowInvalidFace = (pass == 0);
Outer.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
IList <GeometryObject> geomObjs = null;
geomObjs = brepBuilderScope.CreateGeometry();
// We'll return only if we have geometry; otherwise we'll try again with looser validation, if we can.
if (geomObjs != null)
{
if (pass == 1)
{
Importer.TheLog.LogError(Id, "Some faces are missing from this Solid; reading in as an Open Shell instead.", false);
}
return(geomObjs);
}
}
}
return(null);
}
/// <summary>
/// Return geometry for a particular representation item.
/// </summary>
/// <param name="shapeEditScope">The shape edit scope.</param>
/// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
/// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
/// <param name="guid">The guid of an element for which represntation is being created.</param>
/// <returns>The created geometry.</returns>
/// <remarks>As this doesn't inherit from IfcSolidModel, this is a non-virtual CreateGeometry function.</remarks>
protected IList <GeometryObject> CreateGeometry(IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
{
if (Shells.Count == 0)
{
return(null);
}
IList <GeometryObject> geomObjs = null;
using (BuilderScope bs = shapeEditScope.InitializeBuilder(IFCShapeBuilderType.TessellatedShapeBuilder))
{
TessellatedShapeBuilderScope tsBuilderScope = bs as TessellatedShapeBuilderScope;
tsBuilderScope.StartCollectingFaceSet();
foreach (IFCConnectedFaceSet faceSet in Shells)
{
faceSet.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
}
geomObjs = tsBuilderScope.CreateGeometry(guid);
}
if (geomObjs == null || geomObjs.Count == 0)
{
return(null);
}
return(geomObjs);
}
private Tuple <IList <GeometryObject>, bool> CollectFaces(IFCImportShapeEditScope shapeEditScope,
Transform lcs, Transform scaledLcs, string guid)
{
using (BuilderScope bs = shapeEditScope.InitializeBuilder(IFCShapeBuilderType.TessellatedShapeBuilder))
{
TessellatedShapeBuilderScope tsBuilderScope = bs as TessellatedShapeBuilderScope;
tsBuilderScope.StartCollectingFaceSet();
Outer.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
IList <GeometryObject> geomObjs = null;
bool canRevertToMesh = tsBuilderScope.CanRevertToMesh();
int numCreatedFaces = tsBuilderScope.CreatedFacesCount;
int numExpectedFaces = Outer.Faces.Count;
if (numCreatedFaces == numExpectedFaces || (!canRevertToMesh && numCreatedFaces > 0))
{
geomObjs = tsBuilderScope.CreateGeometry(guid);
if (numCreatedFaces < numExpectedFaces)
{
Importer.TheLog.LogWarning(Outer.Id,
"Processing " + numCreatedFaces + " valid faces out of " + numExpectedFaces + " total.", false);
}
}
return(Tuple.Create(geomObjs, canRevertToMesh));
}
}
public BuilderContext(DbContext context, ModelBuilder modelBuilder, BuilderScope scope)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
if (modelBuilder == null)
throw new ArgumentNullException(nameof(modelBuilder));
DbContext = context;
ModelBuilder = modelBuilder;
Scope = scope;
}
public BuilderContext(DbContext context, ModelBuilder modelBuilder, BuilderScope scope)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (modelBuilder == null)
{
throw new ArgumentNullException(nameof(modelBuilder));
}
DbContext = context;
ModelBuilder = modelBuilder;
Scope = scope;
}
private bool ShouldApplyToScope(BuilderScope scope)
{
if (!Configuration.ShouldApplyToScope(scope))
{
return(false);
}
if (_scope == null)
{
return(scope == BuilderScope.PostModelCreating);
}
if (_scope != scope)
{
return(false);
}
return(true);
}
/// <summary>
/// Return geometry for a particular representation item.
/// </summary>
/// <param name="shapeEditScope">The shape edit scope.</param>
/// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
/// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
/// <param name="guid">The guid of an element for which represntation is being created.</param>
/// <returns>The created geometry.</returns>
protected override IList <GeometryObject> CreateGeometryInternal(
IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
{
if (Outer == null || Outer.Faces.Count == 0)
{
return(null);
}
IList <GeometryObject> geomObjs = null;
bool canRevertToMesh = false;
using (BuilderScope bs = shapeEditScope.InitializeBuilder(IFCShapeBuilderType.TessellatedShapeBuilder))
{
TessellatedShapeBuilderScope tsBuilderScope = bs as TessellatedShapeBuilderScope;
tsBuilderScope.StartCollectingFaceSet();
Outer.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
if (tsBuilderScope.CreatedFacesCount == Outer.Faces.Count)
{
geomObjs = tsBuilderScope.CreateGeometry(guid);
}
canRevertToMesh = tsBuilderScope.CanRevertToMesh();
}
if (geomObjs == null || geomObjs.Count == 0)
{
if (canRevertToMesh)
{
using (IFCImportShapeEditScope.BuildPreferenceSetter setter =
new IFCImportShapeEditScope.BuildPreferenceSetter(shapeEditScope, IFCImportShapeEditScope.BuildPreferenceType.AnyMesh))
{
using (BuilderScope newBuilderScope = shapeEditScope.InitializeBuilder(IFCShapeBuilderType.TessellatedShapeBuilder))
{
TessellatedShapeBuilderScope newTsBuilderScope = newBuilderScope as TessellatedShapeBuilderScope;
// Let's see if we can loosen the requirements a bit, and try again.
newTsBuilderScope.StartCollectingFaceSet();
Outer.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
// This needs to be in scope so that we keep the mesh tolerance for vertices.
if (newTsBuilderScope.CreatedFacesCount != 0)
{
if (newTsBuilderScope.CreatedFacesCount != Outer.Faces.Count)
{
Importer.TheLog.LogWarning
(Outer.Id, "Processing " + newTsBuilderScope.CreatedFacesCount + " valid faces out of " + Outer.Faces.Count + " total.", false);
}
geomObjs = newTsBuilderScope.CreateGeometry(guid);
}
}
}
}
}
if (geomObjs == null || geomObjs.Count == 0)
{
// Couldn't use fallback, or fallback didn't work.
Importer.TheLog.LogWarning(Id, "Couldn't create any geometry.", false);
return(null);
}
return(geomObjs);
}
/// <summary>
/// Return geometry for a particular representation item.
/// </summary>
/// <param name="shapeEditScope">The shape edit scope.</param>
/// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
/// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
/// <param name="guid">The guid of an element for which represntation is being created.</param>
/// <returns>The created geometry.</returns>
/// <remarks>As this doesn't inherit from IfcSolidModel, this is a non-virtual CreateSolid function.</remarks>
protected IList <GeometryObject> CreateGeometry(
IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
{
if (Shells.Count == 0)
{
return(null);
}
IList <GeometryObject> geomObjs = null;
int numExpectedFaces = 0;
foreach (IFCConnectedFaceSet faceSet in Shells)
{
numExpectedFaces += faceSet.Faces.Count;
}
// We are going to start by trying to create a Solid, even if we are passed a shell-based model, since we can frequently
// do so. However, if we have even one missing face, we'll loosen the requirements and revert to mesh only.
for (int pass = 0; pass < 2; pass++)
{
IFCImportShapeEditScope.BuildPreferenceType target =
(pass == 0) ? IFCImportShapeEditScope.BuildPreferenceType.AnyGeometry : IFCImportShapeEditScope.BuildPreferenceType.AnyMesh;
using (IFCImportShapeEditScope.BuildPreferenceSetter setter =
new IFCImportShapeEditScope.BuildPreferenceSetter(shapeEditScope, target))
{
using (BuilderScope bs = shapeEditScope.InitializeBuilder(IFCShapeBuilderType.TessellatedShapeBuilder))
{
TessellatedShapeBuilderScope tsBuilderScope = shapeEditScope.BuilderScope as TessellatedShapeBuilderScope;
tsBuilderScope.StartCollectingFaceSet();
foreach (IFCConnectedFaceSet faceSet in Shells)
{
faceSet.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
}
// If we are on our first pass, try again. If we are on our second pass, warn and create the best geometry we can.
if (tsBuilderScope.CreatedFacesCount != numExpectedFaces)
{
if (pass == 0)
{
continue;
}
Importer.TheLog.LogWarning
(Id, "Processing " + tsBuilderScope.CreatedFacesCount + " valid faces out of " + numExpectedFaces + " total.", false);
}
geomObjs = tsBuilderScope.CreateGeometry(guid);
WarnOnTooFewCreatedFaces(geomObjs, numExpectedFaces);
break;
}
}
}
if (geomObjs == null || geomObjs.Count == 0)
{
if (numExpectedFaces != 0)
{
Importer.TheLog.LogError
(Id, "No valid geometry found. This may be due to slivery triangles or other similar geometric issues.", false);
return(null);
}
}
return(geomObjs);
}
protected override void CreateShapeInternal(IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
{
using (BuilderScope bs = shapeEditScope.InitializeBuilder(IFCShapeBuilderType.TessellatedShapeBuilder))
{
base.CreateShapeInternal(shapeEditScope, lcs, scaledLcs, guid);
TessellatedShapeBuilderScope tsBuilderScope = bs as TessellatedShapeBuilderScope;
tsBuilderScope.StartCollectingFaceSet();
// Create triangle face set from CoordIndex. We do not support the Normals yet at this point
foreach (List <int> triIndex in CoordIndex)
{
// This is a defensive check in an unlikely situation that the index is larger than the data
if (triIndex[0] > Coordinates.CoordList.Count || triIndex[1] > Coordinates.CoordList.Count || triIndex[2] > Coordinates.CoordList.Count)
{
continue;
}
tsBuilderScope.StartCollectingFace(GetMaterialElementId(shapeEditScope));
IList <XYZ> loopVertices = new List <XYZ>();
for (int ii = 0; ii < 3; ++ii)
{
int actualVIdx = triIndex[ii] - 1;
if (PnIndex != null)
{
actualVIdx = PnIndex[actualVIdx] - 1;
}
IList <double> v = Coordinates.CoordList[actualVIdx];
loopVertices.Add(new XYZ(v[0], v[1], v[2]));
}
IList <XYZ> transformedVertices = new List <XYZ>();
foreach (XYZ vertex in loopVertices)
{
// Need to apply the project unit scaling here
XYZ scaledVertex = applyProjectUnitScaleVertex(vertex);
transformedVertices.Add(scaledLcs.OfPoint(scaledVertex));
}
// Check triangle that is too narrow (2 vertices are within the tolerance
IList <XYZ> validVertices;
IFCGeometryUtil.CheckAnyDistanceVerticesWithinTolerance(Id, shapeEditScope, transformedVertices, out validVertices);
// We are going to catch any exceptions if the loop is invalid.
// We are going to hope that we can heal the parent object in the TessellatedShapeBuilder.
bool bPotentiallyAbortFace = false;
int count = validVertices.Count;
if (validVertices.Count < 3)
{
Importer.TheLog.LogComment(Id, "Too few distinct loop vertices (" + count + "), ignoring.", false);
bPotentiallyAbortFace = true;
}
else
{
if (!tsBuilderScope.AddLoopVertices(Id, validVertices))
{
bPotentiallyAbortFace = true;
}
}
if (bPotentiallyAbortFace)
{
tsBuilderScope.AbortCurrentFace();
}
else
{
tsBuilderScope.StopCollectingFace();
}
}
IList <GeometryObject> createdGeometries = tsBuilderScope.CreateGeometry(guid);
if (createdGeometries != null)
{
foreach (GeometryObject createdGeometry in createdGeometries)
{
shapeEditScope.AddGeometry(IFCSolidInfo.Create(Id, createdGeometry));
}
}
}
}
protected override void CreateShapeInternal(IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
{
using (BuilderScope bs = shapeEditScope.InitializeBuilder(IFCShapeBuilderType.TessellatedShapeBuilder))
{
base.CreateShapeInternal(shapeEditScope, lcs, scaledLcs, guid);
TessellatedShapeBuilderScope tsBuilderScope = bs as TessellatedShapeBuilderScope;
tsBuilderScope.StartCollectingFaceSet();
// Create the face set from IFCIndexedPolygonalFace
foreach (IFCIndexedPolygonalFace face in Faces)
{
// TODO: Consider adding ability to triangulate here.
tsBuilderScope.StartCollectingFace(GetMaterialElementId(shapeEditScope), false);
IList <XYZ> loopVertices = new List <XYZ>();
foreach (int vertInd in face.CoordIndex)
{
int actualVIdx = vertInd - 1; // IFC starts the list position at 1
if (PnIndex != null)
{
actualVIdx = PnIndex[actualVIdx] - 1;
}
XYZ vertex = Coordinates.CoordList[actualVIdx];
loopVertices.Add(scaledLcs.OfPoint(vertex));
}
List <XYZ> validVertices;
IFCGeometryUtil.CheckAnyDistanceVerticesWithinTolerance(Id, shapeEditScope, loopVertices, out validVertices);
bool bPotentiallyAbortFace = false;
if (!tsBuilderScope.AddLoopVertices(Id, validVertices))
{
bPotentiallyAbortFace = true;
}
// Handle holes
if (face.InnerCoordIndices != null)
{
foreach (IList <int> innerLoop in face.InnerCoordIndices)
{
IList <XYZ> innerLoopVertices = new List <XYZ>();
foreach (int innerVerIdx in innerLoop)
{
int actualVIdx = innerVerIdx - 1;
if (PnIndex != null)
{
actualVIdx = PnIndex[actualVIdx] - 1;
}
XYZ vertex = Coordinates.CoordList[actualVIdx];
// add vertex to the loop
innerLoopVertices.Add(scaledLcs.OfPoint(vertex));
}
List <XYZ> validInnerV;
IFCGeometryUtil.CheckAnyDistanceVerticesWithinTolerance(Id, shapeEditScope, innerLoopVertices, out validInnerV);
if (!tsBuilderScope.AddLoopVertices(Id, validInnerV))
{
bPotentiallyAbortFace = true;
}
}
}
tsBuilderScope.StopCollectingFace(!bPotentiallyAbortFace, false);
}
IList <GeometryObject> createdGeometries = tsBuilderScope.CreateGeometry(guid);
if (createdGeometries != null)
{
foreach (GeometryObject createdGeometry in createdGeometries)
{
shapeEditScope.AddGeometry(IFCSolidInfo.Create(Id, createdGeometry));
}
}
}
}
public virtual bool ShouldApplyToScope(BuilderScope scope)
{
return(true);
}
public override bool ShouldApplyToScope(BuilderScope scope) => _expressions.ShouldApplyToScope?.Invoke(scope) ?? base.ShouldApplyToScope(scope);
public override bool ShouldApplyToScope(BuilderScope scope)
=> _expressions.ShouldApplyToScope?.Invoke(scope) ?? base.ShouldApplyToScope(scope);
