override protected void Process(IFCAnyHandle item)
{
base.Process(item);
IFCBooleanOperator?booleanOperator = IFCEnums.GetSafeEnumerationAttribute <IFCBooleanOperator>(item, "Operator");
if (booleanOperator.HasValue)
{
BooleanOperator = booleanOperator.Value;
}
IFCAnyHandle firstOperand = IFCImportHandleUtil.GetRequiredInstanceAttribute(item, "FirstOperand", true);
FirstOperand = IFCBooleanOperand.ProcessIFCBooleanOperand(firstOperand);
IFCAnyHandle secondOperand = IFCImportHandleUtil.GetRequiredInstanceAttribute(item, "SecondOperand", true);
// We'll allow a solid to be created even if the second operand can't be properly handled.
try
{
SecondOperand = IFCBooleanOperand.ProcessIFCBooleanOperand(secondOperand);
}
catch (Exception ex)
{
SecondOperand = null;
Importer.TheLog.LogError(secondOperand.StepId, ex.Message, false);
}
}
/// <summary>
/// Gets the predefined type from the IfcObject, depending on the file version and entity type.
/// </summary>
/// <param name="ifcElementAssembly">The associated handle.</param>
/// <returns>The predefined type, if any.</returns>
protected override string GetPredefinedType(IFCAnyHandle ifcElementAssembly)
{
IFCElementAssemblyType predefinedType =
IFCEnums.GetSafeEnumerationAttribute <IFCElementAssemblyType>(ifcElementAssembly, "PredefinedType", IFCElementAssemblyType.NotDefined);
return(predefinedType.ToString());
}
/// <summary>
/// Processes IfcRepresentationContext attributes.
/// </summary>
/// <param name="ifcRepresentationContext">The IfcRepresentationContext handle.</param>
override protected void Process(IFCAnyHandle ifcRepresentationContext)
{
base.Process(ifcRepresentationContext);
Identifier = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentationContext, "ContextIdentifier", null);
Type = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentationContext, "ContextType", null);
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationContext, IFCEntityType.IfcGeometricRepresentationContext))
{
bool found = false;
CoordinateSpaceDimension = IFCImportHandleUtil.GetRequiredIntegerAttribute(ifcRepresentationContext, "CoordinateSpaceDimension", out found);
if (!found)
{
CoordinateSpaceDimension = 3; // Don't throw, just set to default 3D.
}
Precision = IFCImportHandleUtil.GetOptionalScaledLengthAttribute(ifcRepresentationContext, "Precision", IFCImportFile.TheFile.Document.Application.VertexTolerance);
IFCAnyHandle worldCoordinateSystem = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcRepresentationContext, "WorldCoordinateSystem", false);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(worldCoordinateSystem))
{
WorldCoordinateSystem = IFCLocation.ProcessIFCAxis2Placement(worldCoordinateSystem);
}
else
{
WorldCoordinateSystem = Transform.Identity;
}
// For IfcGeometricRepresentationSubContext, it seems as if
try
{
IFCAnyHandle trueNorth = IFCImportHandleUtil.GetOptionalInstanceAttribute(ifcRepresentationContext, "TrueNorth");
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(trueNorth))
{
TrueNorth = IFCPoint.ProcessNormalizedIFCDirection(trueNorth);
}
else
{
TrueNorth = XYZ.BasisZ;
}
}
catch
{
TrueNorth = XYZ.BasisZ;
}
if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC2x2 && IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationContext, IFCEntityType.IfcGeometricRepresentationSubContext))
{
IFCAnyHandle parentContext = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcRepresentationContext, "ParentContext", true);
ParentContext = IFCRepresentationContext.ProcessIFCRepresentationContext(parentContext);
TargetScale = IFCImportHandleUtil.GetOptionalPositiveRatioAttribute(ifcRepresentationContext, "TargetScale", 1.0);
TargetView = IFCEnums.GetSafeEnumerationAttribute <IFCGeometricProjection>(ifcRepresentationContext, "TargetView",
IFCGeometricProjection.NotDefined);
UserDefinedTargetView = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentationContext, "UserDefinedTargetView", null);
}
}
}
private static string CoordinatedUniversalTimeOffsetToString(IFCAnyHandle handle, int daylightSavingHour)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(handle))
{
return(null);
}
bool found;
int hour = IFCImportHandleUtil.GetRequiredIntegerAttribute(handle, "HourOffset", out found);
if (!found)
{
return(null);
}
IFCAheadOrBehind?sense = IFCEnums.GetSafeEnumerationAttribute <IFCAheadOrBehind>(handle, "Sense");
if (sense.HasValue && sense.Value == IFCAheadOrBehind.Behind)
{
hour = -hour;
}
hour += daylightSavingHour;
string valueAsString = "UTC" + hour.ToString();
int minute = IFCImportHandleUtil.GetRequiredIntegerAttribute(handle, "MinuteOffset", out found);
if (found)
{
valueAsString += ":" + minute.ToString("D2");
}
return(valueAsString);
}
/// <summary>
/// Processes IfcDoorStyle attributes.
/// </summary>
/// <param name="ifcDoorStyle">The IfcDoorStyle handle.</param>
protected override void Process(IFCAnyHandle ifcDoorStyle)
{
base.Process(ifcDoorStyle);
OperationType = IFCEnums.GetSafeEnumerationAttribute <IFCDoorStyleOperation>(ifcDoorStyle, "OperationType", IFCDoorStyleOperation.NotDefined);
ConstructionType = IFCEnums.GetSafeEnumerationAttribute <IFCDoorStyleConstruction>(ifcDoorStyle, "ConstructionType", IFCDoorStyleConstruction.NotDefined);
}
override protected void Process(IFCAnyHandle item)
{
base.Process(item);
SurfaceSide = IFCEnums.GetSafeEnumerationAttribute <IFCSurfaceSide>(item, "Side", IFCSurfaceSide.Both);
HashSet <IFCAnyHandle> styles = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(item, "Styles");
if (styles == null || styles.Count == 0)
{
Importer.TheLog.LogError(item.StepId, "No style information found, ignoring.", true);
}
foreach (IFCAnyHandle style in styles)
{
try
{
if (IFCAnyHandleUtil.IsSubTypeOf(style, IFCEntityType.IfcSurfaceStyleShading))
{
if (ShadingStyle == null)
{
ShadingStyle = IFCSurfaceStyleShading.ProcessIFCSurfaceStyleShading(style);
}
else
{
Importer.TheLog.LogWarning(item.StepId, "Duplicate IfcSurfaceStyleShading, ignoring.", false);
}
}
else
{
Importer.TheLog.LogUnhandledSubTypeError(style, "IfcSurfaceStyleElementSelect", false);
}
}
catch (Exception ex)
{
Importer.TheLog.LogError(style.StepId, ex.Message, false);
}
}
}
protected override void Process(IFCAnyHandle ifcMaterialLayerSetUsage)
{
base.Process(ifcMaterialLayerSetUsage);
IFCAnyHandle ifcMaterialLayerSet =
IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcMaterialLayerSetUsage, "ForLayerSet", true);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(ifcMaterialLayerSet))
{
MaterialLayerSet = IFCMaterialLayerSet.ProcessIFCMaterialLayerSet(ifcMaterialLayerSet);
}
Direction = IFCEnums.GetSafeEnumerationAttribute(ifcMaterialLayerSetUsage, "LayerSetDirection", IFCLayerSetDirection.Axis3);
DirectionSense = IFCEnums.GetSafeEnumerationAttribute(ifcMaterialLayerSetUsage, "DirectionSense", IFCDirectionSense.Positive);
bool found = false;
Offset = IFCImportHandleUtil.GetRequiredScaledLengthAttribute(ifcMaterialLayerSetUsage, "OffsetFromReferenceLine", out found);
if (!found)
{
Importer.TheLog.LogWarning(ifcMaterialLayerSetUsage.StepId, "No Offset defined, defaulting to 0.", false);
}
}
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 IfcRepresentationContext attributes.
/// </summary>
/// <param name="ifcRepresentationContext">The IfcRepresentationContext handle.</param>
override protected void Process(IFCAnyHandle ifcRepresentationContext)
{
base.Process(ifcRepresentationContext);
Identifier = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentationContext, "ContextIdentifier", null);
Type = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentationContext, "ContextType", null);
if (IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationContext, IFCEntityType.IfcGeometricRepresentationContext))
{
bool found = false;
CoordinateSpaceDimension = IFCImportHandleUtil.GetRequiredIntegerAttribute(ifcRepresentationContext, "CoordinateSpaceDimension", out found);
if (!found)
{
CoordinateSpaceDimension = 3; // Don't throw, just set to default 3D.
}
Precision = IFCImportHandleUtil.GetOptionalScaledLengthAttribute(ifcRepresentationContext, "Precision", IFCImportFile.TheFile.Document.Application.VertexTolerance);
IFCAnyHandle worldCoordinateSystem = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcRepresentationContext, "WorldCoordinateSystem", false);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(worldCoordinateSystem))
{
WorldCoordinateSystem = IFCLocation.ProcessIFCAxis2Placement(worldCoordinateSystem);
}
else
{
WorldCoordinateSystem = Transform.Identity;
}
bool isSubContext = IFCImportFile.TheFile.SchemaVersionAtLeast(IFCSchemaVersion.IFC2x2) &&
IFCAnyHandleUtil.IsSubTypeOf(ifcRepresentationContext, IFCEntityType.IfcGeometricRepresentationSubContext);
if (isSubContext)
{
IFCAnyHandle parentContext = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcRepresentationContext, "ParentContext", true);
ParentContext = IFCRepresentationContext.ProcessIFCRepresentationContext(parentContext);
TrueNorth = ParentContext.TrueNorth;
}
else
{
// This used to fail for IfcGeometricRepresentationSubContext, because the TrueNorth attribute was derived from
// the IfcGeometricRepresentationContext, and the toolkit returned what seemed to be a valid handle that actually
// wasn't. The code has now been rewritten to avoid this issue, but we will keep the try/catch block in case we
// were also catching other serious issues.
try
{
// By default, True North points in the Y-Direction.
IFCAnyHandle trueNorth = IFCImportHandleUtil.GetOptionalInstanceAttribute(ifcRepresentationContext, "TrueNorth");
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(trueNorth))
{
TrueNorth = IFCPoint.ProcessNormalizedIFCDirection(trueNorth);
}
else
{
TrueNorth = XYZ.BasisY;
}
}
catch
{
TrueNorth = XYZ.BasisY;
}
}
if (isSubContext)
{
TargetScale = IFCImportHandleUtil.GetOptionalPositiveRatioAttribute(ifcRepresentationContext, "TargetScale", 1.0);
TargetView = IFCEnums.GetSafeEnumerationAttribute <IFCGeometricProjection>(ifcRepresentationContext, "TargetView",
IFCGeometricProjection.NotDefined);
UserDefinedTargetView = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentationContext, "UserDefinedTargetView", null);
}
}
}
/// <summary>
/// Processes IfcElementAssembly attributes.
/// </summary>
/// <param name="ifcElementAssembly">The IfcElementAssembly handle.</param>
protected override void Process(IFCAnyHandle ifcElementAssembly)
{
base.Process(ifcElementAssembly);
AssemblyPlace = IFCEnums.GetSafeEnumerationAttribute <IFCAssemblyPlace>(ifcElementAssembly, "AssemblyPlace", IFCAssemblyPlace.NotDefined);
}
/// <summary>
/// Processes IfcDistributionPort attributes.
/// </summary>
/// <param name="ifcDistributionPort">The IfcDistributionPort handle.</param>
protected override void Process(IFCAnyHandle ifcDistributionPort)
{
base.Process(ifcDistributionPort);
FlowDirection = IFCEnums.GetSafeEnumerationAttribute <IFCFlowDirection>(ifcDistributionPort, "FlowDirection", IFCFlowDirection.NotDefined);
}
