/// <summary>
/// Create geometry for a particular representation item.
/// </summary>
/// <param name="shapeEditScope">The geometry creation 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>
protected override void CreateShapeInternal(IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
{
if (shapeEditScope.BuilderType != IFCShapeBuilderType.TessellatedShapeBuilder)
{
throw new InvalidOperationException("Currently BrepBuilder is only used to support IFCAdvancedFace");
}
base.CreateShapeInternal(shapeEditScope, lcs, scaledLcs, guid);
// we would only be in this code if we are not processing and IfcAdvancedBrep, since IfcAdvancedBrep must have IfcAdvancedFace
if (shapeEditScope.BuilderScope == null)
{
throw new InvalidOperationException("BuilderScope has not been initialized");
}
TessellatedShapeBuilderScope tsBuilderScope = shapeEditScope.BuilderScope as TessellatedShapeBuilderScope;
bool addFace = true;
bool canTriangulate = (Bounds.Count == 1);
ElementId materialId = GetMaterialElementId(shapeEditScope);
// We can only really triangulate faces with one boundary with 4 vertices,
// but we don't really know how many vertices the boundary has until later.
// So this is just the first block. Later, we can try to extend to generic
// polygons.
tsBuilderScope.StartCollectingFace(materialId, canTriangulate);
foreach (IFCFaceBound faceBound in Bounds)
{
faceBound.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
// If we can't create the outer face boundary, we will abort the creation of this face.
// In that case, return, unless we can triangulate it.
if (!tsBuilderScope.HaveActiveFace())
{
addFace = false;
break;
}
}
tsBuilderScope.StopCollectingFace(addFace, false);
IList <List <XYZ> > delayedFaceBoundaries = CreateTriangulation(tsBuilderScope.DelayedFaceBoundary);
if (delayedFaceBoundaries != null)
{
bool extraFace = false;
foreach (List <XYZ> delayedBoundary in delayedFaceBoundaries)
{
bool addTriangulatedFace = true;
tsBuilderScope.StartCollectingFace(GetMaterialElementId(shapeEditScope), false);
if (!tsBuilderScope.AddLoopVertices(Id, delayedBoundary))
{
Importer.TheLog.LogComment(Id, "Bounded loop plane is slightly non-planar, couldn't triangulate.", false);
addTriangulatedFace = false;
}
tsBuilderScope.StopCollectingFace(addTriangulatedFace, extraFace);
extraFace = true;
}
}
}
/// <summary>
/// Create geometry for a particular representation item.
/// </summary>
/// <param name="shapeEditScope">The geometry creation 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>
protected override void CreateShapeInternal(IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
{
if (shapeEditScope.BuilderType != IFCShapeBuilderType.TessellatedShapeBuilder)
{
throw new InvalidOperationException("Currently BrepBuilder is only used to support IFCAdvancedFace");
}
base.CreateShapeInternal(shapeEditScope, lcs, scaledLcs, guid);
// we would only be in this code if we are not processing and IfcAdvancedBrep, since IfcAdvancedBrep must have IfcAdvancedFace
if (shapeEditScope.BuilderScope == null)
{
throw new InvalidOperationException("BuilderScope has not been initialized");
}
TessellatedShapeBuilderScope tsBuilderScope = shapeEditScope.BuilderScope as TessellatedShapeBuilderScope;
tsBuilderScope.StartCollectingFace(GetMaterialElementId(shapeEditScope));
foreach (IFCFaceBound faceBound in Bounds)
{
faceBound.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
// If we can't create the outer face boundary, we will abort the creation of this face. In that case, return.
if (!tsBuilderScope.HaveActiveFace())
{
tsBuilderScope.AbortCurrentFace();
return;
}
}
tsBuilderScope.StopCollectingFace();
}
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));
}
}
}
}