private void ProcessIFCOffsetCurve3D(IFCAnyHandle ifcCurve)
{
IFCAnyHandle basisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurve, "BasisCurve", false);
if (basisCurve == null)
{
return;
}
bool found = false;
double distance = IFCImportHandleUtil.GetRequiredScaledLengthAttribute(ifcCurve, "Distance", out found);
if (!found)
{
distance = 0.0;
}
try
{
IFCCurve ifcBasisCurve = IFCCurve.ProcessIFCCurve(basisCurve);
if (ifcBasisCurve.Curve != null)
{
Curve = ifcBasisCurve.Curve.CreateOffset(distance, XYZ.BasisZ);
}
else if (ifcBasisCurve.CurveLoop != null)
{
CurveLoop = CurveLoop.CreateViaOffset(ifcBasisCurve.CurveLoop, distance, XYZ.BasisZ);
}
}
catch
{
IFCImportFile.TheLog.LogError(ifcCurve.StepId, "Couldn't create offset curve.", false);
}
}
override protected void Process(IFCAnyHandle solid)
{
base.Process(solid);
IFCAnyHandle directrix = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "Directrix", true);
Directrix = IFCCurve.ProcessIFCCurve(directrix);
IFCAnyHandle referenceSurface = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "ReferenceSurface", true);
ReferenceSurface = IFCSurface.ProcessIFCSurface(referenceSurface);
StartParameter = IFCImportHandleUtil.GetOptionalDoubleAttribute(solid, "StartParam", 0.0);
if (StartParameter < MathUtil.Eps())
{
StartParameter = 0.0;
}
double endParameter = IFCImportHandleUtil.GetOptionalDoubleAttribute(solid, "EndParam", -1.0);
if (!MathUtil.IsAlmostEqual(endParameter, -1.0))
{
if (endParameter < StartParameter + MathUtil.Eps())
{
Importer.TheLog.LogError(solid.StepId, "IfcSurfaceCurveSweptAreaSolid swept curve end parameter less than or equal to start parameter, aborting.", true);
}
EndParameter = endParameter;
}
}
private IFCCurve ProcessIFCCompositeCurveSegment(IFCAnyHandle ifcCurveSegment)
{
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurveSegment, "SameSense", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle ifcParentCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurveSegment, "ParentCurve", true);
IFCCurve parentCurve = null;
using (TemporaryVerboseLogging logger = new TemporaryVerboseLogging())
{
parentCurve = IFCCurve.ProcessIFCCurve(ifcParentCurve);
}
if (parentCurve == null)
{
Importer.TheLog.LogWarning(ifcCurveSegment.StepId, "Error processing ParentCurve (#" + ifcParentCurve.StepId + ") for IfcCompositeCurveSegment; this may be repairable.", false);
return(null);
}
if (parentCurve.IsEmpty())
{
Importer.TheLog.LogWarning(ifcCurveSegment.StepId, "Error processing ParentCurve (#" + ifcParentCurve.StepId + ") for IfcCompositeCurveSegment; this may be repairable.", false);
return(null);
}
return(parentCurve);
}
override protected void Process(IFCAnyHandle ifcGeometricSet)
{
base.Process(ifcGeometricSet);
IList <IFCAnyHandle> elements = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcGeometricSet, "Elements");
if (elements != null)
{
foreach (IFCAnyHandle element in elements)
{
if (IFCAnyHandleUtil.IsSubTypeOf(element, IFCEntityType.IfcCurve))
{
IFCCurve curve = IFCCurve.ProcessIFCCurve(element);
if (curve != null)
{
Curves.Add(curve);
}
}
else
{
Importer.TheLog.LogError(Id, "Unhandled entity type in IfcGeometricSet: " + IFCAnyHandleUtil.GetEntityType(element).ToString(), false);
}
}
}
}
/// <summary>
/// Processes IfcGridAxis attributes.
/// </summary>
/// <param name="ifcGridAxis">The IfcGridAxis handle.</param>
protected override void Process(IFCAnyHandle ifcGridAxis)
{
base.Process(ifcGridAxis);
AxisTag = IFCImportHandleUtil.GetOptionalStringAttribute(ifcGridAxis, "AxisTag", null);
IFCAnyHandle axisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcGridAxis, "AxisCurve", true);
AxisCurve = IFCCurve.ProcessIFCCurve(axisCurve);
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcGridAxis, "SameSense", out found);
SameSense = found ? sameSense : true;
// We are going to check if this grid axis is a vertical duplicate of any existing axis.
// If so, we will throw an exception so that we don't create duplicate grids.
// We will only initialize these values if we actually intend to use them below.
IList <Curve> curves = null;
int curveCount = 0;
ElementId gridId = ElementId.InvalidElementId;
if (Importer.TheCache.GridNameToElementMap.TryGetValue(AxisTag, out gridId))
{
Grid grid = IFCImportFile.TheFile.Document.GetElement(gridId) as Grid;
if (grid != null)
{
IList <Curve> otherCurves = new List <Curve>();
Curve gridCurve = grid.Curve;
if (gridCurve != null)
{
otherCurves.Add(gridCurve);
int matchingGridId = FindMatchingGrid(otherCurves, grid.Id.IntegerValue, ref curves, ref curveCount);
if (matchingGridId != -1)
{
Importer.TheCache.UseGrid(grid);
CreatedElementId = grid.Id;
return;
}
}
}
}
IDictionary <string, IFCGridAxis> gridAxes = IFCImportFile.TheFile.IFCProject.GridAxes;
IFCGridAxis gridAxis = null;
if (gridAxes.TryGetValue(AxisTag, out gridAxis))
{
int matchingGridId = FindMatchingGrid(gridAxis, ref curves, ref curveCount);
if (matchingGridId != -1)
{
DuplicateAxisId = matchingGridId;
return;
}
}
gridAxes.Add(new KeyValuePair <string, IFCGridAxis>(AxisTag, this));
}
private void ProcessIFCCompositeCurveSegment(IFCAnyHandle ifcCurveSegment)
{
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurveSegment, "SameSense", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle parentCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurveSegment, "ParentCurve", true);
IFCCurve ifcParentCurve = IFCCurve.ProcessIFCCurve(parentCurve);
if (ifcParentCurve == null)
{
IFCImportFile.TheLog.LogError(ifcCurveSegment.StepId, "Error processing ParentCurve for IfcCompositeCurveSegment.", false);
return;
}
bool hasCurve = (ifcParentCurve.Curve != null);
bool hasCurveLoop = (ifcParentCurve.CurveLoop != null);
if (!hasCurve && !hasCurveLoop)
{
IFCImportFile.TheLog.LogError(ifcCurveSegment.StepId, "Error processing ParentCurve for IfcCompositeCurveSegment.", false);
return;
}
else
{
// The CurveLoop here is from the parent IfcCurve, which is the IfcCompositeCurve, which will correspond to a CurveLoop.
// IfcCompositiveCurveSegment may be either a curve or a curveloop, which we want to append to the parent curveloop.
if (CurveLoop == null)
{
CurveLoop = new CurveLoop();
}
}
try
{
if (hasCurve)
{
AddCurveToLoop(CurveLoop, ifcParentCurve.Curve, !sameSense, true);
}
else if (hasCurveLoop)
{
foreach (Curve subCurve in ifcParentCurve.CurveLoop)
{
AddCurveToLoop(CurveLoop, subCurve, !sameSense, true);
}
}
}
catch (Exception ex)
{
IFCImportFile.TheLog.LogError(ifcParentCurve.Id, ex.Message, true);
}
}
/// <summary>
/// Processes an IfcRepresentationItem entity handle.
/// </summary>
/// <param name="ifcRepresentationItem">The IfcRepresentationItem handle.</param>
/// <returns>The IFCRepresentationItem object.</returns>
public static IFCRepresentationItem ProcessIFCRepresentationItem(IFCAnyHandle ifcRepresentationItem)
{
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcBooleanResult))
{
return(IFCBooleanResult.ProcessIFCBooleanResult(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcCurve))
{
return(IFCCurve.ProcessIFCCurve(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcFaceBasedSurfaceModel))
{
return(IFCFaceBasedSurfaceModel.ProcessIFCFaceBasedSurfaceModel(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcGeometricSet))
{
return(IFCGeometricSet.ProcessIFCGeometricSet(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcMappedItem))
{
return(IFCMappedItem.ProcessIFCMappedItem(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcShellBasedSurfaceModel))
{
return(IFCShellBasedSurfaceModel.ProcessIFCShellBasedSurfaceModel(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcSolidModel))
{
return(IFCSolidModel.ProcessIFCSolidModel(ifcRepresentationItem));
}
if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC2x2 && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcStyledItem))
{
return(IFCStyledItem.ProcessIFCStyledItem(ifcRepresentationItem));
}
if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC4 && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcTriangulatedFaceSet))
{
return(IFCTriangulatedFaceSet.ProcessIFCTriangulatedFaceSet(ifcRepresentationItem));
}
if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC4Add2 && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcPolygonalFaceSet))
{
return(IFCPolygonalFaceSet.ProcessIFCPolygonalFaceSet(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcTopologicalRepresentationItem))
{
return(IFCTopologicalRepresentationItem.ProcessIFCTopologicalRepresentationItem(ifcRepresentationItem));
}
Importer.TheLog.LogUnhandledSubTypeError(ifcRepresentationItem, IFCEntityType.IfcRepresentationItem, true);
return(null);
}
private IList <Curve> ProcessIFCCompositeCurveSegment(IFCAnyHandle ifcCurveSegment)
{
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurveSegment, "SameSense", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle ifcParentCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurveSegment, "ParentCurve", true);
IFCCurve parentCurve = null;
using (TemporaryVerboseLogging logger = new TemporaryVerboseLogging())
{
parentCurve = IFCCurve.ProcessIFCCurve(ifcParentCurve);
}
if (parentCurve == null)
{
Importer.TheLog.LogWarning(ifcCurveSegment.StepId, "Error processing ParentCurve (#" + ifcParentCurve.StepId + ") for IfcCompositeCurveSegment; this may be repairable.", false);
return(null);
}
bool hasCurve = (parentCurve.Curve != null);
bool hasCurveLoop = (parentCurve.CurveLoop != null);
if (!hasCurve && !hasCurveLoop)
{
Importer.TheLog.LogWarning(ifcCurveSegment.StepId, "Error processing ParentCurve (#" + ifcParentCurve.StepId + ") for IfcCompositeCurveSegment; this may be repairable.", false);
return(null);
}
IList <Curve> curveSegments = new List <Curve>();
if (hasCurve)
{
curveSegments.Add(parentCurve.Curve);
}
else if (hasCurveLoop)
{
foreach (Curve subCurve in parentCurve.CurveLoop)
{
curveSegments.Add(subCurve);
}
}
return(curveSegments);
}
override protected void Process(IFCAnyHandle solid)
{
base.Process(solid);
IFCAnyHandle directrix = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "Directrix", true);
Directrix = IFCCurve.ProcessIFCCurve(directrix);
bool found = false;
Radius = IFCImportHandleUtil.GetRequiredScaledLengthAttribute(solid, "Radius", out found);
if (!found || !Application.IsValidThickness(Radius))
{
Importer.TheLog.LogError(solid.StepId, "IfcSweptDiskSolid radius is invalid, aborting.", true);
}
double innerRadius = IFCImportHandleUtil.GetOptionalScaledLengthAttribute(solid, "InnerRadius", 0.0);
if (Application.IsValidThickness(innerRadius))
{
if (!Application.IsValidThickness(Radius - innerRadius))
{
Importer.TheLog.LogError(solid.StepId, "IfcSweptDiskSolid inner radius is too large, aborting.", true);
}
InnerRadius = innerRadius;
}
StartParameter = IFCImportHandleUtil.GetOptionalDoubleAttribute(solid, "StartParam", 0.0);
if (StartParameter < MathUtil.Eps())
{
StartParameter = 0.0;
}
double endParameter = IFCImportHandleUtil.GetOptionalDoubleAttribute(solid, "EndParam", -1.0);
if (!MathUtil.IsAlmostEqual(endParameter, -1.0))
{
if (endParameter < StartParameter + MathUtil.Eps())
{
Importer.TheLog.LogWarning(solid.StepId, "IfcSweptDiskSolid swept curve end parameter less than or equal to start parameter, ignoring both.", true);
StartParameter = 0.0;
}
else
{
EndParameter = endParameter;
}
}
}
protected override void Process(IFCAnyHandle ifcCurve)
{
base.Process(ifcCurve);
IFCAnyHandle basisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurve, "BasisCurve", false);
if (basisCurve == null)
{
return;
}
IFCAnyHandle dir = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurve, "RefDirection", false);
bool found = false;
double distance = IFCImportHandleUtil.GetRequiredScaledLengthAttribute(ifcCurve, "Distance", out found);
if (!found)
{
distance = 0.0;
}
IFCCurve ifcBasisCurve = IFCCurve.ProcessIFCCurve(basisCurve);
XYZ dirXYZ = (dir == null) ? ifcBasisCurve.GetNormal() : IFCPoint.ProcessNormalizedIFCDirection(dir);
try
{
if (ifcBasisCurve.Curve != null)
{
SetCurve(ifcBasisCurve.Curve.CreateOffset(distance, XYZ.BasisZ));
}
else
{
CurveLoop baseCurveLoop = ifcBasisCurve.GetTheCurveLoop();
if (baseCurveLoop != null)
{
SetCurveLoop(CurveLoop.CreateViaOffset(baseCurveLoop, distance, XYZ.BasisZ));
}
}
}
catch
{
Importer.TheLog.LogError(ifcCurve.StepId, "Couldn't create offset curve.", false);
}
}
/// <summary>
/// Processes an IfcRepresentationItem entity handle.
/// </summary>
/// <param name="ifcRepresentationItem">The IfcRepresentationItem handle.</param>
/// <returns>The IFCRepresentationItem object.</returns>
public static IFCRepresentationItem ProcessIFCRepresentationItem(IFCAnyHandle ifcRepresentationItem)
{
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcBooleanResult))
{
return(IFCBooleanResult.ProcessIFCBooleanResult(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcConnectedFaceSet))
{
return(IFCConnectedFaceSet.ProcessIFCConnectedFaceSet(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcCurve))
{
return(IFCCurve.ProcessIFCCurve(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcFaceBasedSurfaceModel))
{
return(IFCFaceBasedSurfaceModel.ProcessIFCFaceBasedSurfaceModel(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcGeometricSet))
{
return(IFCGeometricSet.ProcessIFCGeometricSet(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcMappedItem))
{
return(IFCMappedItem.ProcessIFCMappedItem(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcShellBasedSurfaceModel))
{
return(IFCShellBasedSurfaceModel.ProcessIFCShellBasedSurfaceModel(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcSolidModel))
{
return(IFCSolidModel.ProcessIFCSolidModel(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcStyledItem))
{
return(IFCStyledItem.ProcessIFCStyledItem(ifcRepresentationItem));
}
IFCImportFile.TheLog.LogUnhandledSubTypeError(ifcRepresentationItem, IFCEntityType.IfcRepresentationItem, true);
return(null);
}
protected override void Process(IFCAnyHandle ifcEdgeCurve)
{
base.Process(ifcEdgeCurve);
IFCAnyHandle edgeGeometry = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcEdgeCurve, "EdgeGeometry", true);
EdgeGeometry = IFCCurve.ProcessIFCCurve(edgeGeometry);
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcEdgeCurve, "SameSense", out found);
if (found)
{
SameSense = sameSense;
}
else
{
Importer.TheLog.LogWarning(ifcEdgeCurve.StepId, "Cannot find SameSense attribute, defaulting to true", false);
SameSense = true;
}
}
override protected void Process(IFCAnyHandle solid)
{
base.Process(solid);
bool found = false;
bool agreementFlag = IFCImportHandleUtil.GetRequiredBooleanAttribute(solid, "AgreementFlag", out found);
if (found)
{
AgreementFlag = agreementFlag;
}
IFCAnyHandle baseSurface = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "BaseSurface", true);
BaseSurface = IFCSurface.ProcessIFCSurface(baseSurface);
if (!(BaseSurface is IFCPlane))
{
Importer.TheLog.LogUnhandledSubTypeError(baseSurface, IFCEntityType.IfcSurface, true);
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(solid, IFCEntityType.IfcPolygonalBoundedHalfSpace))
{
IFCAnyHandle position = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "Position", false);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(position))
{
BaseBoundingCurveTransform = IFCLocation.ProcessIFCAxis2Placement(position);
}
else
{
BaseBoundingCurveTransform = Transform.Identity;
}
IFCAnyHandle boundaryCurveHandle = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "PolygonalBoundary", true);
BaseBoundingCurve = IFCCurve.ProcessIFCCurve(boundaryCurveHandle);
if (BaseBoundingCurve == null || BaseBoundingCurve.GetTheCurveLoop() == null)
{
Importer.TheLog.LogError(Id, "IfcPolygonalBoundedHalfSpace has an invalid boundary, ignoring.", true);
}
}
}
private void ProcessIFCTrimmedCurve(IFCAnyHandle ifcCurve)
{
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurve, "SenseAgreement", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle basisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurve, "BasisCurve", true);
IFCCurve ifcBasisCurve = IFCCurve.ProcessIFCCurve(basisCurve);
if (ifcBasisCurve == null || (ifcBasisCurve.Curve == null && ifcBasisCurve.CurveLoop == null))
{
// LOG: ERROR: Error processing BasisCurve # for IfcTrimmedCurve #.
return;
}
if (ifcBasisCurve.Curve == null)
{
// LOG: ERROR: Expected a single curve, not a curve loop for BasisCurve # for IfcTrimmedCurve #.
return;
}
IFCData trim1 = ifcCurve.GetAttribute("Trim1");
if (trim1.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
IFCData trim2 = ifcCurve.GetAttribute("Trim2");
if (trim2.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
string trimPreferenceAsString = IFCAnyHandleUtil.GetEnumerationAttribute(ifcCurve, "MasterRepresentation");
IFCTrimmingPreference trimPreference = IFCTrimmingPreference.Parameter;
if (trimPreferenceAsString != null)
{
trimPreference = (IFCTrimmingPreference)Enum.Parse(typeof(IFCTrimmingPreference), trimPreferenceAsString, true);
}
double param1 = 0.0, param2 = 0.0;
try
{
GetTrimParameters(trim1, trim2, ifcBasisCurve, trimPreference, out param1, out param2);
}
catch (Exception ex)
{
IFCImportFile.TheLog.LogError(ifcCurve.StepId, ex.Message, false);
return;
}
Curve baseCurve = ifcBasisCurve.Curve;
if (baseCurve.IsCyclic)
{
if (!sameSense)
{
MathUtil.Swap(ref param1, ref param2);
}
if (param2 < param1)
{
param2 = MathUtil.PutInRange(param2, param1 + Math.PI, 2 * Math.PI);
}
if (param2 - param1 > 2.0 * Math.PI - MathUtil.Eps())
{
// LOG: WARNING: #Id: IfcTrimmedCurve length is greater than 2*PI, leaving unbound.
Curve = baseCurve;
return;
}
Curve = baseCurve.Clone();
Curve.MakeBound(param1, param2);
}
else
{
if (MathUtil.IsAlmostEqual(param1, param2))
{
// LOG: ERROR: Param1 = Param2 for IfcTrimmedCurve #, ignoring.
return;
}
if (param1 > param2 - MathUtil.Eps())
{
// LOG: WARNING: Param1 > Param2 for IfcTrimmedCurve #, reversing.
MathUtil.Swap(ref param1, ref param2);
return;
}
Curve copyCurve = baseCurve.Clone();
copyCurve.MakeBound(param1, param2);
if (sameSense)
{
Curve = copyCurve;
}
else
{
Curve = copyCurve.CreateReversed();
}
}
}
protected override void Process(IFCAnyHandle ifcCurve)
{
base.Process(ifcCurve);
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurve, "SenseAgreement", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle basisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurve, "BasisCurve", true);
IFCCurve ifcBasisCurve = IFCCurve.ProcessIFCCurve(basisCurve);
if (ifcBasisCurve == null || (ifcBasisCurve.IsEmpty()))
{
// LOG: ERROR: Error processing BasisCurve # for IfcTrimmedCurve #.
return;
}
if (ifcBasisCurve.Curve == null)
{
// LOG: ERROR: Expected a single curve, not a curve loop for BasisCurve # for IfcTrimmedCurve #.
return;
}
IFCData trim1 = ifcCurve.GetAttribute("Trim1");
if (trim1.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
IFCData trim2 = ifcCurve.GetAttribute("Trim2");
if (trim2.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
// Note that these are the "unprocessed" values. These can be used for, e.g., adding up the IFC parameter length
// of the file, to account for export errors. The "processed" values can be determined from the Revit curves.
Trim1 = GetRawTrimParameter(trim1);
Trim2 = GetRawTrimParameter(trim2);
IFCTrimmingPreference trimPreference = IFCEnums.GetSafeEnumerationAttribute <IFCTrimmingPreference>(ifcCurve, "MasterRepresentation", IFCTrimmingPreference.Parameter);
double param1 = 0.0, param2 = 0.0;
Curve baseCurve = ifcBasisCurve.Curve;
try
{
GetTrimParameters(ifcBasisCurve.Id, trim1, trim2, baseCurve, trimPreference, out param1, out param2);
if (NeedToReverseBaseCurve(baseCurve, param1, param2, trimPreference))
{
Importer.TheLog.LogWarning(Id, "Invalid Param1 > Param2 for non-cyclic IfcTrimmedCurve using Cartesian trimming preference, reversing.", false);
baseCurve = baseCurve.CreateReversed();
GetTrimParameters(ifcBasisCurve.Id, trim1, trim2, baseCurve, trimPreference, out param1, out param2);
}
}
catch (Exception ex)
{
Importer.TheLog.LogError(ifcCurve.StepId, ex.Message, false);
return;
}
if (MathUtil.IsAlmostEqual(param1, param2))
{
Importer.TheLog.LogError(Id, "Param1 = Param2 for IfcTrimmedCurve #, ignoring.", false);
return;
}
Curve curve = null;
if (baseCurve.IsCyclic)
{
double period = baseCurve.Period;
if (!sameSense)
{
MathUtil.Swap(ref param1, ref param2);
}
// We want to make sure both values are within period of one another.
param1 = MathUtil.PutInRange(param1, 0, period);
param2 = MathUtil.PutInRange(param2, 0, period);
if (param2 < param1)
{
param2 = MathUtil.PutInRange(param2, param1 + period / 2, period);
}
// This is effectively an unbound curve.
double numberOfPeriods = (param2 - param1) / period;
if (MathUtil.IsAlmostEqual(numberOfPeriods, Math.Round(numberOfPeriods)))
{
Importer.TheLog.LogWarning(Id, "Start and end parameters indicate a zero-length closed curve, assuming unbound is intended.", false);
curve = baseCurve;
}
else
{
curve = baseCurve.Clone();
if (!SafelyBoundCurve(curve, param1, param2))
{
return;
}
}
}
else
{
if (param1 > param2 - MathUtil.Eps())
{
Importer.TheLog.LogWarning(Id, "Param1 > Param2 for IfcTrimmedCurve #, reversing.", false);
MathUtil.Swap(ref param1, ref param2);
sameSense = !sameSense;
}
Curve copyCurve = baseCurve.Clone();
double length = param2 - param1;
if (length <= IFCImportFile.TheFile.ShortCurveTolerance)
{
string lengthAsString = IFCUnitUtil.FormatLengthAsString(length);
Importer.TheLog.LogError(Id, "curve length of " + lengthAsString + " is invalid, ignoring.", false);
return;
}
if (!SafelyBoundCurve(copyCurve, param1, param2))
{
return;
}
if (sameSense)
{
curve = copyCurve;
}
else
{
curve = copyCurve.CreateReversed();
}
}
CurveLoop curveLoop = new CurveLoop();
curveLoop.Append(curve);
SetCurveLoop(curveLoop);
}
protected override void Process(IFCAnyHandle ifcCurve)
{
base.Process(ifcCurve);
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurve, "SenseAgreement", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle basisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurve, "BasisCurve", true);
IFCCurve ifcBasisCurve = IFCCurve.ProcessIFCCurve(basisCurve);
if (ifcBasisCurve == null || (ifcBasisCurve.Curve == null && ifcBasisCurve.CurveLoop == null))
{
// LOG: ERROR: Error processing BasisCurve # for IfcTrimmedCurve #.
return;
}
if (ifcBasisCurve.Curve == null)
{
// LOG: ERROR: Expected a single curve, not a curve loop for BasisCurve # for IfcTrimmedCurve #.
return;
}
IFCData trim1 = ifcCurve.GetAttribute("Trim1");
if (trim1.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
IFCData trim2 = ifcCurve.GetAttribute("Trim2");
if (trim2.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
IFCTrimmingPreference trimPreference = IFCEnums.GetSafeEnumerationAttribute <IFCTrimmingPreference>(ifcCurve, "MasterRepresentation", IFCTrimmingPreference.Parameter);
double param1 = 0.0, param2 = 0.0;
try
{
GetTrimParameters(trim1, trim2, ifcBasisCurve, trimPreference, out param1, out param2);
}
catch (Exception ex)
{
Importer.TheLog.LogError(ifcCurve.StepId, ex.Message, false);
return;
}
Curve baseCurve = ifcBasisCurve.Curve;
if (baseCurve.IsCyclic)
{
if (!sameSense)
{
MathUtil.Swap(ref param1, ref param2);
}
if (param2 < param1)
{
param2 = MathUtil.PutInRange(param2, param1 + Math.PI, 2 * Math.PI);
}
if (param2 - param1 > 2.0 * Math.PI - MathUtil.Eps())
{
Importer.TheLog.LogWarning(ifcCurve.StepId, "IfcTrimmedCurve length is greater than 2*PI, leaving unbound.", false);
Curve = baseCurve;
return;
}
Curve = baseCurve.Clone();
try
{
Curve.MakeBound(param1, param2);
}
catch (Exception ex)
{
if (ex.Message.Contains("too small"))
{
Curve = null;
Importer.TheLog.LogError(Id, "curve length is invalid, ignoring.", false);
return;
}
else
{
throw ex;
}
}
}
else
{
if (MathUtil.IsAlmostEqual(param1, param2))
{
Importer.TheLog.LogError(Id, "Param1 = Param2 for IfcTrimmedCurve #, ignoring.", false);
return;
}
if (param1 > param2 - MathUtil.Eps())
{
Importer.TheLog.LogWarning(Id, "Param1 > Param2 for IfcTrimmedCurve #, reversing.", false);
MathUtil.Swap(ref param1, ref param2);
return;
}
Curve copyCurve = baseCurve.Clone();
double length = param2 - param1;
if (length <= IFCImportFile.TheFile.Document.Application.ShortCurveTolerance)
{
string lengthAsString = IFCUnitUtil.FormatLengthAsString(length);
Importer.TheLog.LogError(Id, "curve length of " + lengthAsString + " is invalid, ignoring.", false);
return;
}
copyCurve.MakeBound(param1, param2);
if (sameSense)
{
Curve = copyCurve;
}
else
{
Curve = copyCurve.CreateReversed();
}
}
CurveLoop = new CurveLoop();
CurveLoop.Append(Curve);
}
/// <summary>
/// Processes an IfcRepresentationItem entity handle.
/// </summary>
/// <param name="ifcRepresentationItem">The IfcRepresentationItem handle.</param>
/// <returns>The IFCRepresentationItem object.</returns>
public static IFCRepresentationItem ProcessIFCRepresentationItem(IFCAnyHandle ifcRepresentationItem)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(ifcRepresentationItem))
{
Importer.TheLog.LogNullError(IFCEntityType.IfcRepresentationItem);
return(null);
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcBooleanResult))
{
return(IFCBooleanResult.ProcessIFCBooleanResult(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcCurve))
{
return(IFCCurve.ProcessIFCCurve(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcFaceBasedSurfaceModel))
{
return(IFCFaceBasedSurfaceModel.ProcessIFCFaceBasedSurfaceModel(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcGeometricSet))
{
return(IFCGeometricSet.ProcessIFCGeometricSet(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcMappedItem))
{
return(IFCMappedItem.ProcessIFCMappedItem(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcShellBasedSurfaceModel))
{
return(IFCShellBasedSurfaceModel.ProcessIFCShellBasedSurfaceModel(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcSolidModel))
{
return(IFCSolidModel.ProcessIFCSolidModel(ifcRepresentationItem));
}
if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC2x2 && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcStyledItem))
{
return(IFCStyledItem.ProcessIFCStyledItem(ifcRepresentationItem));
}
if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC4 && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcTriangulatedFaceSet))
{
return(IFCTriangulatedFaceSet.ProcessIFCTriangulatedFaceSet(ifcRepresentationItem));
}
// There is no way to actually determine an IFC4Add2 file vs. a "vanilla" IFC4 file, which is
// obsolete. The try/catch here allows us to read these obsolete files without crashing.
try
{
if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC4 && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcPolygonalFaceSet))
{
return(IFCPolygonalFaceSet.ProcessIFCPolygonalFaceSet(ifcRepresentationItem));
}
}
catch
{
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcTopologicalRepresentationItem))
{
return(IFCTopologicalRepresentationItem.ProcessIFCTopologicalRepresentationItem(ifcRepresentationItem));
}
Importer.TheLog.LogUnhandledSubTypeError(ifcRepresentationItem, IFCEntityType.IfcRepresentationItem, true);
return(null);
}
/// <summary>
/// Processes an IfcRepresentationItem entity handle.
/// </summary>
/// <param name="ifcRepresentationItem">The IfcRepresentationItem handle.</param>
/// <returns>The IFCRepresentationItem object.</returns>
public static IFCRepresentationItem ProcessIFCRepresentationItem(IFCAnyHandle ifcRepresentationItem)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(ifcRepresentationItem))
{
Importer.TheLog.LogNullError(IFCEntityType.IfcRepresentationItem);
return(null);
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcMappedItem))
{
return(IFCMappedItem.ProcessIFCMappedItem(ifcRepresentationItem));
}
if (IFCImportFile.TheFile.SchemaVersionAtLeast(IFCSchemaVersion.IFC2x2) && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcStyledItem))
{
return(IFCStyledItem.ProcessIFCStyledItem(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcTopologicalRepresentationItem))
{
return(IFCTopologicalRepresentationItem.ProcessIFCTopologicalRepresentationItem(ifcRepresentationItem));
}
// TODO: Move everything below to IFCGeometricRepresentationItem, once it is created.
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcBooleanResult))
{
return(IFCBooleanResult.ProcessIFCBooleanResult(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcCurve))
{
return(IFCCurve.ProcessIFCCurve(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcFaceBasedSurfaceModel))
{
return(IFCFaceBasedSurfaceModel.ProcessIFCFaceBasedSurfaceModel(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcGeometricSet))
{
return(IFCGeometricSet.ProcessIFCGeometricSet(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcPoint))
{
return(IFCPoint.ProcessIFCPoint(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcShellBasedSurfaceModel))
{
return(IFCShellBasedSurfaceModel.ProcessIFCShellBasedSurfaceModel(ifcRepresentationItem));
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcSolidModel))
{
return(IFCSolidModel.ProcessIFCSolidModel(ifcRepresentationItem));
}
// TODO: Move the items below to IFCGeometricRepresentationItem->IFCTessellatedItem->IfcTessellatedFaceSet.
if (IFCImportFile.TheFile.SchemaVersionAtLeast(IFCSchemaVersion.IFC4Obsolete) && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcTriangulatedFaceSet))
{
return(IFCTriangulatedFaceSet.ProcessIFCTriangulatedFaceSet(ifcRepresentationItem));
}
// There is no way to actually determine an IFC4Add2 file vs. a "vanilla" IFC4 file, which is
// obsolete. The try/catch here allows us to read these obsolete files without crashing.
try
{
if (IFCImportFile.TheFile.SchemaVersionAtLeast(IFCSchemaVersion.IFC4) && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationItem, IFCEntityType.IfcPolygonalFaceSet))
{
return(IFCPolygonalFaceSet.ProcessIFCPolygonalFaceSet(ifcRepresentationItem));
}
}
catch (Exception ex)
{
// Once we fail once, downgrade the schema so we don't try again.
if (IFCImportFile.HasUndefinedAttribute(ex))
{
IFCImportFile.TheFile.DowngradeIFC4SchemaTo(IFCSchemaVersion.IFC4Add1Obsolete);
}
else
{
throw ex;
}
}
Importer.TheLog.LogUnhandledSubTypeError(ifcRepresentationItem, IFCEntityType.IfcRepresentationItem, true);
return(null);
}