/// <summary>
/// Processes IfcProject attributes.
/// </summary>
/// <param name="ifcProjectHandle">The IfcProject handle.</param>
protected override void Process(IFCAnyHandle ifcProjectHandle)
{
IFCAnyHandle unitsInContext = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcProjectHandle, "UnitsInContext", false);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(unitsInContext))
{
IList <IFCAnyHandle> units = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(unitsInContext, "Units");
if (units != null)
{
m_UnitsInContext = new HashSet <IFCUnit>();
foreach (IFCAnyHandle unit in units)
{
IFCUnit ifcUnit = IFCImportFile.TheFile.IFCUnits.ProcessIFCProjectUnit(unit);
if (!IFCUnit.IsNullOrInvalid(ifcUnit))
{
m_UnitsInContext.Add(ifcUnit);
}
}
}
else
{
Importer.TheLog.LogMissingRequiredAttributeError(unitsInContext, "Units", false);
}
}
// We need to process the units before we process the rest of the file, since we will scale values as we go along.
base.Process(ifcProjectHandle);
// process true north - take the first valid representation context that has a true north value.
HashSet <IFCAnyHandle> repContexts = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcProjectHandle, "RepresentationContexts");
if (repContexts != null)
{
foreach (IFCAnyHandle geomRepContextHandle in repContexts)
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(geomRepContextHandle) &&
IFCAnyHandleUtil.IsSubTypeOf(geomRepContextHandle, IFCEntityType.IfcGeometricRepresentationContext))
{
IFCAnyHandle trueNorthHandle = IFCAnyHandleUtil.GetInstanceAttribute(geomRepContextHandle, "TrueNorth");
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(trueNorthHandle))
{
List <double> trueNorthDir = IFCAnyHandleUtil.GetAggregateDoubleAttribute <List <double> >(trueNorthHandle, "DirectionRatios");
if (trueNorthDir != null && trueNorthDir.Count >= 2)
{
m_TrueNorthDirection = trueNorthDir;
break;
}
}
}
}
}
// Special read of IfcPresentationLayerAssignment if the INVERSE flag isn't properly set in the EXPRESS file.
if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC2x2)
{
IFCPresentationLayerAssignment.ProcessAllLayerAssignments();
}
}
/// <summary>
/// Creates or populates Revit elements based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
protected override void Create(Document doc)
{
Transform lcs = (ObjectLocation != null) ? ObjectLocation.TotalTransform : Transform.Identity;
CreateOneDirection(UAxes, doc, lcs);
CreateOneDirection(VAxes, doc, lcs);
CreateOneDirection(WAxes, doc, lcs);
ISet <ElementId> createdElementIds = new HashSet <ElementId>();
GetCreatedElementIds(createdElementIds);
// We want to get the presentation layer from the Grid representation, if any.
IFCPresentationLayerAssignment defaultLayerAssignment = GetTheFirstPresentationLayerAssignment();
string defaultLayerAssignmentName = (defaultLayerAssignment != null) ? defaultLayerAssignment.Name : null;
bool hasDefaultLayerAssignmentName = !string.IsNullOrWhiteSpace(defaultLayerAssignmentName);
foreach (ElementId createdElementId in createdElementIds)
{
CreatedElementId = createdElementId;
SetCurrentPresentationLayerNames(defaultLayerAssignmentName, hasDefaultLayerAssignmentName);
CreateParameters(doc);
}
CreatedElementId = ElementId.InvalidElementId;
}
override protected void Process(IFCAnyHandle item)
{
base.Process(item);
LayerAssignment = IFCPresentationLayerAssignment.GetTheLayerAssignment(item);
List<IFCAnyHandle> styledByItems = IFCAnyHandleUtil.GetAggregateInstanceAttribute<List<IFCAnyHandle>>(item, "StyledByItem");
if (styledByItems != null && styledByItems.Count > 0)
{
// We can only handle one styled item, but we allow the possiblity that there are duplicates. Do a top-level check.
foreach (IFCAnyHandle styledByItem in styledByItems)
{
if (!IFCAnyHandleUtil.IsSubTypeOf(styledByItem, IFCEntityType.IfcStyledItem))
{
Importer.TheLog.LogUnexpectedTypeError(styledByItem, IFCEntityType.IfcStyledItem, false);
StyledByItem = null;
break;
}
else
{
if (StyledByItem == null)
StyledByItem = IFCStyledItem.ProcessIFCStyledItem(styledByItem);
else
{
IFCStyledItem compStyledByItem = IFCStyledItem.ProcessIFCStyledItem(styledByItem);
if (!StyledByItem.IsEquivalentTo(compStyledByItem))
{
Importer.TheLog.LogWarning(Id, "Multiple inconsistent styled items found for this item; using first one.", false);
break;
}
}
}
}
}
}
/// <summary>
/// Does a top-level check to see if this entity may be equivalent to otherEntity.
/// </summary>
/// <param name="otherEntity">The other IFCEntity.</param>
/// <returns>True if they are equivalent, false if they aren't, null if not enough information.</returns>
/// <remarks>This isn't intended to be an exhaustive check, and isn't implemented for all types. This is intended
/// to be used by derived classes.</remarks>
public override bool?MaybeEquivalentTo(IFCEntity otherEntity)
{
bool?maybeEquivalentTo = base.MaybeEquivalentTo(otherEntity);
if (maybeEquivalentTo.HasValue)
{
return(maybeEquivalentTo.Value);
}
if (!(otherEntity is IFCPresentationLayerAssignment))
{
return(false);
}
IFCPresentationLayerAssignment other = otherEntity as IFCPresentationLayerAssignment;
if (!IFCNamingUtil.SafeStringsAreEqual(Name, other.Name))
{
return(false);
}
if (!IFCNamingUtil.SafeStringsAreEqual(Description, other.Description))
{
return(false);
}
if (!IFCNamingUtil.SafeStringsAreEqual(Identifier, other.Identifier))
{
return(false);
}
return(null);
}
/// <summary>
/// Deal with missing "LayerAssignments" in IFC2x3 EXP file.
/// </summary>
/// <param name="layerAssignment">The layer assignment to add to this representation.</param>
public void PostProcessLayerAssignment(IFCPresentationLayerAssignment layerAssignment)
{
if (LayerAssignment == null)
{
LayerAssignment = layerAssignment;
}
else
{
IFCImportDataUtil.CheckLayerAssignmentConsistency(LayerAssignment, layerAssignment, Id);
}
}
/// <summary>
/// Check if two IFCPresentationLayerAssignments are equivalent, and warn if they aren't/
/// </summary>
/// <param name="originalAssignment">The original layer assignment in this representation.</param>
/// <param name="layerAssignment">The layer assignment to add to this representation.</param>
/// <returns>True if the layer assignments are consistent; false otherwise.</returns>
static public bool CheckLayerAssignmentConsistency(IFCPresentationLayerAssignment originalAssignment,
IFCPresentationLayerAssignment layerAssignment, int id)
{
if ((originalAssignment != null) && (!originalAssignment.IsEquivalentTo(layerAssignment)))
{
Importer.TheLog.LogWarning(id, "Multiple inconsistent layer assignment items found for this item; using first one.", false);
return false;
}
return true;
}
static public void ProcessAllLayerAssignments()
{
IList <IFCAnyHandle> layerAssignments = IFCImportFile.TheFile.GetInstances(IFCEntityType.IfcPresentationLayerAssignment, true);
if (layerAssignments != null)
{
foreach (IFCAnyHandle layerAssignment in layerAssignments)
{
IFCPresentationLayerAssignment.ProcessIFCPresentationLayerAssignment(layerAssignment);
}
}
}
/// <summary>
/// Get the one layer assignment associated to this handle, if it is defined.
/// </summary>
/// <param name="ifcLayeredItem">The handle assumed to be an IfcRepresentation or IfcRepresentationItem.</param>
/// <param name="isIFCRepresentation">True if the handle is an IfcRepresentation. This determines the name of the inverse attribute.</param>
/// <returns>The associated IfcLayerAssignment.</returns>
/// <remarks>This deals with the issues that:
/// 1. the default IFC2x3 EXP file doesn't have this inverse attribute set.
/// 2. The name changed in IFC4.
/// 3. The attribute didn't exist before IFC2x3.</remarks>
static public IFCPresentationLayerAssignment GetTheLayerAssignment(IFCAnyHandle ifcLayeredItem, bool isIFCRepresentation)
{
IFCPresentationLayerAssignment theLayerAssignment = null;
IList <IFCAnyHandle> layerAssignments = null;
if (IFCImportFile.TheFile.Options.AllowUseLayerAssignments)
{
// Inverse attribute changed names in IFC4 for IfcRepresentationItem only.
string layerAssignmentsAttributeName = (isIFCRepresentation || IFCImportFile.TheFile.SchemaVersion < IFCSchemaVersion.IFC4) ? "LayerAssignments" : "LayerAssignment";
try
{
layerAssignments = IFCAnyHandleUtil.GetAggregateInstanceAttribute
<List <IFCAnyHandle> >(ifcLayeredItem, layerAssignmentsAttributeName);
}
catch
{
IFCImportFile.TheFile.Options.AllowUseLayerAssignments = false;
layerAssignments = null;
}
}
if (layerAssignments != null && layerAssignments.Count > 0)
{
// We can only handle one layer assignment, but we allow the possiblity that there are duplicates. Do a top-level check.
foreach (IFCAnyHandle layerAssignment in layerAssignments)
{
if (!IFCAnyHandleUtil.IsSubTypeOf(layerAssignment, IFCEntityType.IfcPresentationLayerAssignment))
{
Importer.TheLog.LogUnexpectedTypeError(layerAssignment, IFCEntityType.IfcStyledItem, false);
theLayerAssignment = null;
break;
}
else
{
IFCPresentationLayerAssignment compLayerAssignment = IFCPresentationLayerAssignment.ProcessIFCPresentationLayerAssignment(layerAssignment);
if (theLayerAssignment == null)
{
theLayerAssignment = compLayerAssignment;
continue;
}
if (!IFCImportDataUtil.CheckLayerAssignmentConsistency(theLayerAssignment, compLayerAssignment, ifcLayeredItem.StepId))
{
break;
}
}
}
}
return(theLayerAssignment);
}
/// <summary>
/// Get the one layer assignment associated to this handle, if it is defined.
/// </summary>
/// <param name="ifcLayeredItem">The handle assumed to be an IfcRepresentation or IfcRepresentationItem.</param>
/// <returns>The associated IfcLayerAssignment.</returns>
static public IFCPresentationLayerAssignment GetTheLayerAssignment(IFCAnyHandle ifcLayeredItem)
{
IFCAnyHandle layerAssignmentHnd;
if (!Importer.TheCache.LayerAssignment.TryGetValue(ifcLayeredItem, out layerAssignmentHnd))
{
return(null);
}
IFCPresentationLayerAssignment layerAssignment =
ProcessIFCPresentationLayerAssignment(layerAssignmentHnd);
return(layerAssignment);
}
override protected void Process(IFCAnyHandle item)
{
base.Process(item);
LayerAssignment = IFCPresentationLayerAssignment.GetTheLayerAssignment(item);
// IFC2x has a different representation for styled items which we don't support.
ICollection <IFCAnyHandle> styledByItems = null;
if (Importer.TheCache.StyledByItems.TryGetValue(item, out styledByItems))
{
if (styledByItems != null && styledByItems.Count > 0)
{
// We can only handle one styled item, but we allow the possiblity that there are duplicates. Do a top-level check.
foreach (IFCAnyHandle styledByItem in styledByItems)
{
if (!IFCAnyHandleUtil.IsSubTypeOf(styledByItem, IFCEntityType.IfcStyledItem))
{
Importer.TheLog.LogUnexpectedTypeError(styledByItem, IFCEntityType.IfcStyledItem, false);
StyledByItem = null;
break;
}
else
{
if (StyledByItem == null)
{
StyledByItem = IFCStyledItem.ProcessIFCStyledItem(styledByItem);
}
else
{
IFCStyledItem compStyledByItem = IFCStyledItem.ProcessIFCStyledItem(styledByItem);
if (!StyledByItem.IsEquivalentTo(compStyledByItem))
{
Importer.TheLog.LogWarning(Id, "Multiple inconsistent styled items found for this item; using first one.", false);
break;
}
}
}
}
}
}
}
override protected void Process(IFCAnyHandle item)
{
base.Process(item);
LayerAssignment = IFCPresentationLayerAssignment.GetTheLayerAssignment(item, false);
List <IFCAnyHandle> styledByItems = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(item, "StyledByItem");
if (styledByItems != null && styledByItems.Count > 0)
{
// We can only handle one styled item, but we allow the possiblity that there are duplicates. Do a top-level check.
foreach (IFCAnyHandle styledByItem in styledByItems)
{
if (!IFCAnyHandleUtil.IsSubTypeOf(styledByItem, IFCEntityType.IfcStyledItem))
{
Importer.TheLog.LogUnexpectedTypeError(styledByItem, IFCEntityType.IfcStyledItem, false);
StyledByItem = null;
break;
}
else
{
if (StyledByItem == null)
{
StyledByItem = IFCStyledItem.ProcessIFCStyledItem(styledByItem);
}
else
{
IFCStyledItem compStyledByItem = IFCStyledItem.ProcessIFCStyledItem(styledByItem);
if (!StyledByItem.IsEquivalentTo(compStyledByItem))
{
Importer.TheLog.LogWarning(Id, "Multiple inconsistent styled items found for this item; using first one.", false);
break;
}
}
}
}
}
}
/// <summary>
/// Processes IfcRepresentation attributes.
/// </summary>
/// <param name="ifcRepresentation">The IfcRepresentation handle.</param>
override protected void Process(IFCAnyHandle ifcRepresentation)
{
base.Process(ifcRepresentation);
IFCAnyHandle representationContext = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcRepresentation, "ContextOfItems", false);
if (representationContext != null)
{
Context = IFCRepresentationContext.ProcessIFCRepresentationContext(representationContext);
}
string identifier = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentation, "RepresentationIdentifier", null);
Identifier = GetRepresentationIdentifier(identifier, ifcRepresentation);
Type = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentation, "RepresentationType", null);
HashSet <IFCAnyHandle> items =
IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcRepresentation, "Items");
LayerAssignment = IFCPresentationLayerAssignment.GetTheLayerAssignment(ifcRepresentation, true);
foreach (IFCAnyHandle item in items)
{
IFCRepresentationItem repItem = null;
try
{
if (NotAllowedInRepresentation(item))
{
IFCEntityType entityType = IFCAnyHandleUtil.GetEntityType(item);
Importer.TheLog.LogWarning(item.StepId, "Ignoring unhandled representation item of type " + entityType.ToString() + " in " +
Identifier.ToString() + " representation.", true);
continue;
}
// Special processing for bounding boxes - only IfcBoundingBox allowed.
if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcBoundingBox))
{
// Don't read in Box represenation unless options allow it.
if (IFCImportFile.TheFile.Options.ProcessBoundingBoxGeometry == IFCProcessBBoxOptions.Never)
{
Importer.TheLog.LogWarning(item.StepId, "BoundingBox not imported with ProcessBoundingBoxGeometry=Never", false);
}
else
{
if (BoundingBox != null)
{
Importer.TheLog.LogWarning(item.StepId, "Found second IfcBoundingBox representation item, ignoring.", false);
continue;
}
BoundingBox = ProcessBoundingBox(item);
}
}
else
{
repItem = IFCRepresentationItem.ProcessIFCRepresentationItem(item);
}
}
catch (Exception ex)
{
Importer.TheLog.LogError(item.StepId, ex.Message, false);
}
if (repItem != null)
{
RepresentationItems.Add(repItem);
}
}
}
/// <summary>
/// Deal with missing "LayerAssignments" in IFC2x3 EXP file.
/// </summary>
/// <param name="layerAssignment">The layer assignment to add to this representation.</param>
public void PostProcessLayerAssignment(IFCPresentationLayerAssignment layerAssignment)
{
if (LayerAssignment == null)
LayerAssignment = layerAssignment;
else
IFCImportDataUtil.CheckLayerAssignmentConsistency(LayerAssignment, layerAssignment, Id);
}
/// <summary>
/// Processes IfcProject attributes.
/// </summary>
/// <param name="ifcProjectHandle">The IfcProject handle.</param>
protected override void Process(IFCAnyHandle ifcProjectHandle)
{
IFCAnyHandle unitsInContext = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcProjectHandle, "UnitsInContext", false);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(unitsInContext))
{
IList <IFCAnyHandle> units = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(unitsInContext, "Units");
if (units != null)
{
m_UnitsInContext = new HashSet <IFCUnit>();
foreach (IFCAnyHandle unit in units)
{
IFCUnit ifcUnit = IFCImportFile.TheFile.IFCUnits.ProcessIFCProjectUnit(unit);
if (!IFCUnit.IsNullOrInvalid(ifcUnit))
{
m_UnitsInContext.Add(ifcUnit);
}
}
}
else
{
Importer.TheLog.LogMissingRequiredAttributeError(unitsInContext, "Units", false);
}
}
// We need to process the units before we process the rest of the file, since we will scale values as we go along.
base.Process(ifcProjectHandle);
// process true north - take the first valid representation context that has a true north value.
HashSet <IFCAnyHandle> repContexts = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcProjectHandle, "RepresentationContexts");
if (repContexts != null)
{
foreach (IFCAnyHandle geomRepContextHandle in repContexts)
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(geomRepContextHandle) &&
IFCAnyHandleUtil.IsSubTypeOf(geomRepContextHandle, IFCEntityType.IfcGeometricRepresentationContext))
{
IFCRepresentationContext context = IFCRepresentationContext.ProcessIFCRepresentationContext(geomRepContextHandle);
if (TrueNorthDirection == null && context.TrueNorth != null)
{
// TODO: Verify that we don't have inconsistent true norths. If we do, warn.
TrueNorthDirection = new UV(context.TrueNorth.X, context.TrueNorth.Y);
}
if (WorldCoordinateSystem == null && context.WorldCoordinateSystem != null && !context.WorldCoordinateSystem.IsIdentity)
{
WorldCoordinateSystem = context.WorldCoordinateSystem;
}
}
}
}
// Special read of IfcPresentationLayerAssignment if the INVERSE flag isn't properly set in the EXPRESS file.
if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC2x2)
{
IFCPresentationLayerAssignment.ProcessAllLayerAssignments();
}
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="scope">The associated shape edit scope.</param>
/// <param name="item">The current styled item.</param>
public IFCMaterialStack(IFCImportShapeEditScope scope, IFCStyledItem styledItem, IFCPresentationLayerAssignment layerAssignment)
{
m_Scope = scope;
if (styledItem != null)
m_MaterialElementId = styledItem.GetMaterialElementId(scope);
else if (layerAssignment != null)
m_MaterialElementId = layerAssignment.GetMaterialElementId(scope);
if (m_MaterialElementId != ElementId.InvalidElementId)
m_Scope.PushMaterialId(m_MaterialElementId);
}
/// <summary>
/// Processes IfcRepresentation attributes.
/// </summary>
/// <param name="ifcRepresentation">The IfcRepresentation handle.</param>
override protected void Process(IFCAnyHandle ifcRepresentation)
{
base.Process(ifcRepresentation);
IFCAnyHandle representationContext = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcRepresentation, "ContextOfItems", false);
if (representationContext != null)
Context = IFCRepresentationContext.ProcessIFCRepresentationContext(representationContext);
string identifier = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentation, "RepresentationIdentifier", null);
Identifier = GetRepresentationIdentifier(identifier, ifcRepresentation);
// Don't read in Box represenation unless options allow it.
bool isBoundingBox = (Identifier == IFCRepresentationIdentifier.Box);
if (isBoundingBox && !IFCImportFile.TheFile.Options.ProcessBoundingBoxGeometry)
throw new InvalidOperationException("BoundingBox not imported with ProcessBoundingBoxGeometry=false");
Type = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentation, "RepresentationType", null);
HashSet<IFCAnyHandle> items =
IFCAnyHandleUtil.GetAggregateInstanceAttribute<HashSet<IFCAnyHandle>>(ifcRepresentation, "Items");
LayerAssignment = IFCPresentationLayerAssignment.GetTheLayerAssignment(ifcRepresentation);
foreach (IFCAnyHandle item in items)
{
IFCRepresentationItem repItem = null;
try
{
if (NotAllowedInRepresentation(item))
{
IFCEntityType entityType = IFCAnyHandleUtil.GetEntityType(item);
IFCImportFile.TheLog.LogWarning(item.StepId, "Ignoring unhandled representation item of type " + entityType.ToString() + " in " +
Identifier.ToString() + " representation.", true);
continue;
}
// Special processing for bounding boxes - only IfcBoundingBox allowed.
if (isBoundingBox)
{
BoundingBox = ProcessBoundingBox(item);
if (BoundingBox != null)
break;
}
else
repItem = IFCRepresentationItem.ProcessIFCRepresentationItem(item);
}
catch (Exception ex)
{
IFCImportFile.TheLog.LogError(item.StepId, ex.Message, false);
}
if (repItem != null)
RepresentationItems.Add(repItem);
}
}