/// <summary> /// Processes IfcTypeObject attributes. /// </summary> /// <param name="ifcTypeProduct">The IfcTypeProduct handle.</param> protected override void Process(IFCAnyHandle ifcTypeProduct) { base.Process(ifcTypeProduct); Tag = IFCAnyHandleUtil.GetStringAttribute(ifcTypeProduct, "Tag"); IList <IFCAnyHandle> representationMapsHandle = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcTypeProduct, "RepresentationMaps"); if (representationMapsHandle != null && representationMapsHandle.Count > 0) { foreach (IFCAnyHandle representationMapHandle in representationMapsHandle) { IFCRepresentationMap representationMap = IFCRepresentationMap.ProcessIFCRepresentationMap(representationMapHandle); if (representationMap != null) { RepresentationMaps.Add(representationMap); // Traditionally we would create a "dummy" DirectShapeType for each IfcRepresentationMap. In the case where the IfcRepresentationMap is not used by another other IfcTypeProduct, // we would like to stop creating the "dummy" DirectShapeType and store the geometry in the DirectShapeType associated with the IfcTypeProduct. However, IfcRepresentationMap // does not have an INVERSE relationship to its IfcTypeProduct(s), at least in IFC2x3. // As such, we keep track of the IfcRepresentationMaps that have the relationship described above for future correspondence. RegisterRepresentationMapWithTypeProject(representationMap, this); } } } }
/// <summary> /// Finds all related objects in IfcRelAssigns. /// </summary> /// <param name="ifcRelAssigns">The IfcRelAssigns handle.</param> /// <returns>The related objects, or null if not found.</returns> static public ICollection <IFCObjectDefinition> ProcessRelatedObjects(IFCAnyHandle ifcRelAssignsOrAggregates) { try { ValidateIFCRelAssignsOrAggregates(ifcRelAssignsOrAggregates); } catch { //LOG: ERROR: Couldn't find valid IfcRelAssignsToGroup for IfcGroup. return(null); } HashSet <IFCAnyHandle> relatedObjects = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcRelAssignsOrAggregates, "RelatedObjects"); // Receiving apps need to decide whether to post an error or not. if (relatedObjects == null) { return(null); } ICollection <IFCObjectDefinition> relatedObjectSet = new HashSet <IFCObjectDefinition>(); foreach (IFCAnyHandle relatedObject in relatedObjects) { IFCObjectDefinition objectDefinition = IFCObjectDefinition.ProcessIFCObjectDefinition(relatedObject); if (objectDefinition != null) { relatedObjectSet.Add(objectDefinition); } } return(relatedObjectSet); }
override protected void Process(IFCAnyHandle styledItem) { base.Process(styledItem); IFCAnyHandle item = IFCImportHandleUtil.GetOptionalInstanceAttribute(styledItem, "Item"); if (!IFCAnyHandleUtil.IsNullOrHasNoValue(item)) { Item = IFCRepresentationItem.ProcessIFCRepresentationItem(item); } Name = IFCImportHandleUtil.GetOptionalStringAttribute(styledItem, "Name", null); List <IFCAnyHandle> styles = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(styledItem, "Styles"); if (styles == null || styles.Count == 0 || IFCAnyHandleUtil.IsNullOrHasNoValue(styles[0])) { Importer.TheLog.LogMissingRequiredAttributeError(styledItem, "Styles", true); } if (styles.Count > 1) { Importer.TheLog.LogWarning(styledItem.StepId, "Multiple presentation styles found for IfcStyledItem - using first.", false); } Styles = IFCPresentationStyleAssignment.ProcessIFCPresentationStyleAssignment(styles[0]); }
/// <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(); } }
private IList <IFCGridAxis> ProcessOneAxis(IFCAnyHandle ifcGrid, string axisName) { IList <IFCGridAxis> gridAxes = new List <IFCGridAxis>(); List <IFCAnyHandle> ifcAxes = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcGrid, axisName); if (ifcAxes != null) { foreach (IFCAnyHandle axis in ifcAxes) { IFCGridAxis gridAxis = IFCGridAxis.ProcessIFCGridAxis(axis); if (gridAxis != null) { if (gridAxis.DuplicateAxisId == -1) { gridAxes.Add(gridAxis); } else { IFCEntity originalEntity; if (IFCImportFile.TheFile.EntityMap.TryGetValue(gridAxis.DuplicateAxisId, out originalEntity)) { IFCGridAxis originalGridAxis = originalEntity as IFCGridAxis; if (originalGridAxis != null) { gridAxes.Add(originalGridAxis); } } } } } } return(gridAxes); }
protected override void Process(IFCAnyHandle ifcCurve) { base.Process(ifcCurve); IList <IFCAnyHandle> points = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcCurve, "Points"); int numPoints = points.Count; if (numPoints < 2) { string msg = "IfcPolyLine had " + numPoints + ", expected at least 2, ignoring"; Importer.TheLog.LogError(Id, msg, false); return; } IList <XYZ> pointXYZs = new List <XYZ>(); foreach (IFCAnyHandle point in points) { XYZ pointXYZ = IFCPoint.ProcessScaledLengthIFCCartesianPoint(point); pointXYZs.Add(pointXYZ); } if (pointXYZs.Count != numPoints) { Importer.TheLog.LogError(Id, "Some of the IFC points cannot be converted to Revit points", true); } CurveLoop = IFCGeometryUtil.CreatePolyCurveLoop(pointXYZs, points, Id, false); Curve = IFCGeometryUtil.CreateCurveFromPolyCurveLoop(CurveLoop, pointXYZs); }
override protected void Process(IFCAnyHandle ifcPolyLoop) { base.Process(ifcPolyLoop); List <IFCAnyHandle> ifcPolygon = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcPolyLoop, "Polygon"); if (ifcPolygon == null) { return; // TODO: WARN } Polygon = IFCPoint.ProcessScaledLengthIFCCartesianPoints(ifcPolygon); // Check for duplicate points, including wrapping around, and remove them. int numVertices = Polygon.Count; for (int ii = numVertices - 1; (ii != -1) && numVertices >= 3; ii--) { if (MathUtil.IsAlmostEqualAbsolute(Polygon[ii], Polygon[(ii + 1) % numVertices])) { Importer.TheLog.LogError(ifcPolyLoop.StepId, "The polygon vertex at index " + ii + " is a duplicate, removing.", false); Polygon.RemoveAt(ii); numVertices--; } } if (numVertices < 3) { // This used to throw an error. However, we found files that threw this error // thousands of times, causing incredibly slow links. Instead, null out the // data and log an error. Polygon = null; Importer.TheLog.LogError(ifcPolyLoop.StepId, "Polygon attribute has only " + numVertices + " vertices, 3 expected.", false); } }
/// <summary> /// Processes IfcObjectDefinition attributes. /// </summary> /// <param name="ifcObjectDefinition">The IfcObjectDefinition handle.</param> protected override void Process(IFCAnyHandle ifcObjectDefinition) { base.Process(ifcObjectDefinition); ShapeType = GetShapeType(ifcObjectDefinition); // If we aren't importing this category, skip processing. if (!IFCCategoryUtil.CanImport(EntityType, ShapeType)) { throw new InvalidOperationException("Don't Import"); } // Before IFC2x3, IfcTypeObject did not have IsDecomposedBy. HashSet <IFCAnyHandle> elemSet = null; if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC2x3 || !IFCAnyHandleUtil.IsSubTypeOf(ifcObjectDefinition, IFCEntityType.IfcTypeObject)) { elemSet = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcObjectDefinition, "IsDecomposedBy"); } if (elemSet != null) { foreach (IFCAnyHandle elem in elemSet) { ProcessIFCRelDecomposes(elem); } } HashSet <IFCAnyHandle> hasAssociations = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcObjectDefinition, "HasAssociations"); if (hasAssociations != null) { foreach (IFCAnyHandle hasAssociation in hasAssociations) { if (IFCAnyHandleUtil.IsSubTypeOf(hasAssociation, IFCEntityType.IfcRelAssociatesMaterial)) { ProcessIFCRelAssociatesMaterial(hasAssociation); } else { IFCImportFile.TheLog.LogUnhandledSubTypeError(hasAssociation, IFCEntityType.IfcRelAssociates, false); } } } // The default IFC2x3_TC1.exp file does not have this INVERSE attribute correctly set. Encapsulate this function. ISet <IFCAnyHandle> hasAssignments = IFCImportHandleUtil.GetHasAssignments(ifcObjectDefinition); if (hasAssignments != null) { foreach (IFCAnyHandle hasAssignment in hasAssignments) { ProcessIFCRelAssigns(hasAssignment); } } IFCImportFile.TheLog.AddToElementCount(); }
override protected void Process(IFCAnyHandle ifcManifoldSolidBrep) { base.Process(ifcManifoldSolidBrep); // We will not fail if the transform is not given, but instead assume it to be the identity. IFCAnyHandle ifcOuter = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcManifoldSolidBrep, "Outer", true); Outer = IFCClosedShell.ProcessIFCClosedShell(ifcOuter); if (IFCAnyHandleUtil.IsSubTypeOf(ifcManifoldSolidBrep, IFCEntityType.IfcFacetedBrepWithVoids)) { HashSet <IFCAnyHandle> ifcVoids = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcManifoldSolidBrep, "Voids"); if (ifcVoids != null) { foreach (IFCAnyHandle ifcVoid in ifcVoids) { try { Inners.Add(IFCClosedShell.ProcessIFCClosedShell(ifcVoid)); } catch { // LOG: WARNING: #: Invalid inner shell ifcVoid.StepId, ignoring. } } } } }
protected override void Process(IFCAnyHandle ifcMaterialConstituentSet) { base.Process(ifcMaterialConstituentSet); IList <IFCAnyHandle> ifcMaterialConsitutuents = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcMaterialConstituentSet, "MaterialConstituents"); if (ifcMaterialConsitutuents == null) { Importer.TheLog.LogError(ifcMaterialConstituentSet.Id, "Expected at least 1 MaterialConsituent, found none.", false); return; } foreach (IFCAnyHandle ifcMaterialConstituent in ifcMaterialConsitutuents) { IFCMaterialConstituent materialConstituent = IFCMaterialConstituent.ProcessIFCMaterialConstituent(ifcMaterialConstituent); if (materialConstituent != null) { MaterialConstituents.Add(materialConstituent); } } Name = IFCImportHandleUtil.GetOptionalStringAttribute(ifcMaterialConstituentSet, "Name", null); Description = IFCImportHandleUtil.GetOptionalStringAttribute(ifcMaterialConstituentSet, "Description", null); }
protected override void Process(IFCAnyHandle ifcMaterial) { base.Process(ifcMaterial); Name = IFCImportHandleUtil.GetRequiredStringAttribute(ifcMaterial, "Name", true); List <IFCAnyHandle> hasRepresentation = null; if (IFCImportFile.TheFile.SchemaVersion >= IFCSchemaVersion.IFC2x3) { hasRepresentation = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcMaterial, "HasRepresentation"); } if (hasRepresentation != null && hasRepresentation.Count == 1) { if (!IFCAnyHandleUtil.IsSubTypeOf(hasRepresentation[0], IFCEntityType.IfcMaterialDefinitionRepresentation)) { Importer.TheLog.LogUnexpectedTypeError(hasRepresentation[0], IFCEntityType.IfcMaterialDefinitionRepresentation, false); } else { MaterialDefinitionRepresentation = IFCProductRepresentation.ProcessIFCProductRepresentation(hasRepresentation[0]); } } Importer.TheLog.AddToElementCount(); }
/// <summary> /// Processes IfcOpeningElement attributes. /// </summary> /// <param name="ifcOpeningElement">The IfcOpeningElement handle.</param> protected override void Process(IFCAnyHandle ifcOpeningElement) { base.Process(ifcOpeningElement); ICollection <IFCAnyHandle> hasFillings = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcOpeningElement, "HasFillings"); if (hasFillings != null) { // Assume that there is only one filling for the opening, and take first found. foreach (IFCAnyHandle hasFilling in hasFillings) { IFCAnyHandle relatedFillingElement = IFCAnyHandleUtil.GetInstanceAttribute(hasFilling, "RelatedBuildingElement"); if (IFCAnyHandleUtil.IsNullOrHasNoValue(relatedFillingElement)) { continue; } IFCEntity filledByElement; IFCImportFile.TheFile.EntityMap.TryGetValue(relatedFillingElement.StepId, out filledByElement); if (filledByElement == null) { FilledByElement = IFCElement.ProcessIFCElement(relatedFillingElement); } else { FilledByElement = filledByElement as IFCElement; } FilledByElement.FillsOpening = this; break; } } }
/// <summary> /// Processes IfcTypeObject attributes. /// </summary> /// <param name="ifcTypeObject">The IfcTypeObject handle.</param> protected override void Process(IFCAnyHandle ifcTypeObject) { base.Process(ifcTypeObject); HashSet <IFCAnyHandle> propertySets = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcTypeObject, "HasPropertySets"); if (propertySets != null) { m_IFCPropertySets = new Dictionary <string, IFCPropertySetDefinition>(); foreach (IFCAnyHandle propertySet in propertySets) { IFCPropertySetDefinition ifcPropertySetDefinition = IFCPropertySetDefinition.ProcessIFCPropertySetDefinition(propertySet); if (ifcPropertySetDefinition != null) { string name = ifcPropertySetDefinition.Name; if (string.IsNullOrWhiteSpace(name)) { name = IFCAnyHandleUtil.GetEntityType(propertySet).ToString() + " " + propertySet.StepId; } m_IFCPropertySets[name] = ifcPropertySetDefinition; } } } }
/// <summary> /// Processes IfcPort attributes. /// </summary> /// <param name="ifcPort">The IfcPort handle.</param> protected override void Process(IFCAnyHandle ifcPort) { base.Process(ifcPort); // We will delay processing the containment information to the PostProcess stp. For complicated systems, creating all of these // during the standard Process step may result in a stack overflow. if (IFCImportFile.TheFile.SchemaVersionAtLeast(IFCSchemaVersion.IFC4)) { HashSet <IFCAnyHandle> containedIn = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcPort, "ContainedIn"); if (containedIn != null && containedIn.Count != 0) { m_ContainedInHandle = containedIn.First(); } } else { m_ContainedInHandle = IFCAnyHandleUtil.GetInstanceAttribute(ifcPort, "ContainedIn"); } HashSet <IFCAnyHandle> connectedFrom = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcPort, "ConnectedFrom"); if (connectedFrom != null && connectedFrom.Count != 0) { m_ConnectedFromHandle = connectedFrom.First(); } HashSet <IFCAnyHandle> connectedTo = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcPort, "ConnectedTo"); if (connectedTo != null && connectedTo.Count != 0) { m_ConnectedToHandle = connectedTo.First(); } }
override protected void Process(IFCAnyHandle ifcConnectedFaceSet) { base.Process(ifcConnectedFaceSet); HashSet <IFCAnyHandle> ifcCfsFaces = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcConnectedFaceSet, "CfsFaces"); if (ifcCfsFaces == null || ifcCfsFaces.Count == 0) { throw new InvalidOperationException("#" + ifcConnectedFaceSet.StepId + ": no faces in connected face set, aborting."); } foreach (IFCAnyHandle ifcCfsFace in ifcCfsFaces) { try { Faces.Add(IFCFace.ProcessIFCFace(ifcCfsFace)); } catch { Importer.TheLog.LogWarning(ifcCfsFace.StepId, "Invalid face, ignoring.", false); } } if (Faces.Count == 0) { throw new InvalidOperationException("#" + ifcConnectedFaceSet.StepId + ": no faces, aborting."); } }
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); } } } }
override protected void Process(IFCAnyHandle ifcPolyLoop) { base.Process(ifcPolyLoop); List <IFCAnyHandle> ifcPolygon = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcPolyLoop, "Polygon"); if (ifcPolygon == null) { return; // TODO: WARN } Polygon = IFCPoint.ProcessScaledLengthIFCCartesianPoints(ifcPolygon); int numVertices = Polygon.Count; if (numVertices > 1) { if (Polygon[0].IsAlmostEqualTo(Polygon[numVertices - 1])) { // LOG: Warning: #: First and last points are almost identical, removing extra point. Polygon.RemoveAt(numVertices - 1); numVertices--; } } if (numVertices < 3) { throw new InvalidOperationException("#" + ifcPolyLoop.StepId + ": Polygon attribute has only " + numVertices + " vertices, 3 expected."); } }
protected override void Process(IFCAnyHandle ifcMaterialLayerSet) { base.Process(ifcMaterialLayerSet); IList <IFCAnyHandle> ifcMaterialLayers = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcMaterialLayerSet, "MaterialLayers"); if (ifcMaterialLayers == null) { Importer.TheLog.LogError(ifcMaterialLayerSet.Id, "Expected at least 1 IfcMaterialLayer, found none.", false); return; } foreach (IFCAnyHandle ifcMaterialLayer in ifcMaterialLayers) { IFCMaterialLayer materialLayer = null; if (materialLayer is IFCMaterialLayerWithOffsets) { materialLayer = IFCMaterialLayerWithOffsets.ProcessIFCMaterialLayerWithOffsets(ifcMaterialLayer); } else { materialLayer = IFCMaterialLayer.ProcessIFCMaterialLayer(ifcMaterialLayer); } if (materialLayer != null) { MaterialLayers.Add(materialLayer); } } LayerSetName = IFCImportHandleUtil.GetOptionalStringAttribute(ifcMaterialLayerSet, "LayerSetName", null); }
override protected void Process(IFCAnyHandle ifcPolyLoop) { base.Process(ifcPolyLoop); List <IFCAnyHandle> ifcPolygon = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcPolyLoop, "Polygon"); if (ifcPolygon == null) { return; // TODO: WARN } Polygon = IFCPoint.ProcessScaledLengthIFCCartesianPoints(ifcPolygon); int numVertices = Polygon.Count; if (numVertices > 1) { if (MathUtil.IsAlmostEqualAbsolute(Polygon[0], Polygon[numVertices - 1])) { // LOG: Warning: #: First and last points are almost identical, removing extra point. Polygon.RemoveAt(numVertices - 1); numVertices--; } } if (numVertices < 3) { // This used to throw an error. However, we found files that threw this error // thousands of times, causing incredibly slow links. Instead, null out the // data and log an error. Polygon = null; Importer.TheLog.LogError(ifcPolyLoop.StepId, "Polygon attribute has only " + numVertices + " vertices, 3 expected.", false); } }
/// <summary> /// Processes IfcElement attributes. /// </summary> /// <param name="ifcElement">The IfcElement handle.</param> protected override void Process(IFCAnyHandle ifcElement) { base.Process(ifcElement); m_Tag = IFCAnyHandleUtil.GetStringAttribute(ifcElement, "Tag"); ICollection <IFCAnyHandle> hasOpenings = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcElement, "HasOpenings"); if (hasOpenings != null) { foreach (IFCAnyHandle hasOpening in hasOpenings) { IFCAnyHandle relatedOpeningElement = IFCAnyHandleUtil.GetInstanceAttribute(hasOpening, "RelatedOpeningElement"); if (IFCAnyHandleUtil.IsNullOrHasNoValue(relatedOpeningElement)) { continue; } IFCFeatureElementSubtraction opening = IFCFeatureElementSubtraction.ProcessIFCFeatureElementSubtraction(relatedOpeningElement); if (opening != null) { opening.VoidsElement = this; Openings.Add(opening); } } } }
protected override void Process(IFCAnyHandle ifcPolygonalFaceSet) { base.Process(ifcPolygonalFaceSet); bool?closed = IFCAnyHandleUtil.GetBooleanAttribute(ifcPolygonalFaceSet, "Closed"); if (closed != null) { Closed = closed; } IList <IFCAnyHandle> facesHnds = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcPolygonalFaceSet, "Faces"); if (facesHnds != null) { if (facesHnds.Count > 0) { Faces = new List <IFCIndexedPolygonalFace>(); } foreach (IFCAnyHandle facesHnd in facesHnds) { Faces.Add(IFCIndexedPolygonalFace.ProcessIFCIndexedPolygonalFace(facesHnd)); } } }
override protected void Process(IFCAnyHandle item) { base.Process(item); IList <IFCAnyHandle> layerStyles = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(item, "LayerStyles"); foreach (IFCAnyHandle layerStyle in layerStyles) { if (layerStyle == null) { Importer.TheLog.LogNullError(IFCEntityType.IfcPresentationStyle); continue; } IFCPresentationStyle presentationStyle = IFCPresentationStyle.ProcessIFCPresentationStyle(layerStyle); if (presentationStyle != null) { LayerStyles.Add(presentationStyle); } else { Importer.TheLog.LogUnhandledSubTypeError(layerStyle, "IfcPresentationStyle", false); } } }
/// <summary> /// Processes IfcSpatialStructureElement attributes. /// </summary> /// <param name="ifcSpatialStructureElement">The IfcSpatialStructureElement handle.</param> protected override void Process(IFCAnyHandle ifcSpatialStructureElement) { base.Process(ifcSpatialStructureElement); LongName = IFCImportHandleUtil.GetOptionalStringAttribute(ifcSpatialStructureElement, "LongName", null); HashSet <IFCAnyHandle> elemSet = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcSpatialStructureElement, "ContainsElements"); if (elemSet != null) { if (m_IFCProducts == null) { m_IFCProducts = new HashSet <IFCProduct>(); } foreach (IFCAnyHandle elem in elemSet) { ProcessIFCRelContainedInSpatialStructure(elem); } } if (IFCImportFile.TheFile.SchemaVersion > IFCSchemaVersion.IFC2x || IFCAnyHandleUtil.IsSubTypeOf(ifcSpatialStructureElement, IFCEntityType.IfcBuilding)) { HashSet <IFCAnyHandle> systemSet = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcSpatialStructureElement, "ServicedBySystems"); if (systemSet != null) { foreach (IFCAnyHandle system in systemSet) { ProcessIFCRelServicesBuildings(system); } } } }
override protected void Process(IFCAnyHandle ifcFace) { if (IFCAnyHandleUtil.IsSubTypeOf(ifcFace, IFCEntityType.IfcFaceSurface)) { // Only allow IfcFaceSurface is the surface is a plane. IFCAnyHandle faceSurface = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcFace, "FaceSurface", false); if (!IFCAnyHandleUtil.IsNullOrHasNoValue(faceSurface)) { IFCSurface surface = IFCSurface.ProcessIFCSurface(faceSurface); if (!(surface is IFCPlane)) { IFCImportFile.TheLog.LogError(ifcFace.StepId, "cannot handle IfcFaceSurface with FaceSurface of type " + IFCAnyHandleUtil.GetEntityType(faceSurface).ToString(), true); } } } base.Process(ifcFace); HashSet <IFCAnyHandle> ifcBounds = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcFace, "Bounds"); if (ifcBounds == null || ifcBounds.Count == 0) { throw new InvalidOperationException("#" + ifcFace.StepId + ": no face boundaries, aborting."); } foreach (IFCAnyHandle ifcBound in ifcBounds) { try { Bounds.Add(IFCFaceBound.ProcessIFCFaceBound(ifcBound)); } catch { // LOG: WARNING: #: Invalid face boundary ifcBound.StepId, ignoring. } } if (Bounds.Count == 0) { throw new InvalidOperationException("#" + ifcFace.StepId + ": no face boundaries, aborting."); } // Give warning if too many outer bounds. We won't care how they are designated, regardless. bool hasOuter = false; foreach (IFCFaceBound faceBound in Bounds) { if (faceBound.IsOuter) { if (hasOuter) { // LOG: WARNING: #: Too many outer boundary loops for IfcFace. break; } hasOuter = true; } } }
/// <summary> /// Finds contained elements. /// </summary> /// <param name="ifcRelHandle">The relation handle.</param> void ProcessIFCRelContainedInSpatialStructure(IFCAnyHandle ifcRelHandle) { HashSet <IFCAnyHandle> elemSet = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcRelHandle, "RelatedElements"); if (elemSet == null) { Importer.TheLog.LogMissingRequiredAttributeError(ifcRelHandle, "RelatedElements", false); return; } foreach (IFCAnyHandle elem in elemSet) { try { IFCProduct product = IFCProduct.ProcessIFCProduct(elem); if (product != null) { product.ContainingStructure = this; m_IFCProducts.Add(product); } } catch (Exception ex) { Importer.TheLog.LogError(elem.StepId, ex.Message, false); } } }
/// <summary> /// Processes an IFC element quantity. /// </summary> /// <param name="ifcElementQuantity">The IfcElementQuantity object.</param> protected override void Process(IFCAnyHandle ifcElementQuantity) { base.Process(ifcElementQuantity); MethodOfMeasurement = IFCImportHandleUtil.GetOptionalStringAttribute(ifcElementQuantity, "MethodOfMeasurement", null); HashSet <IFCAnyHandle> quantities = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcElementQuantity, "Quantities"); if (quantities != null) { m_IFCQuantities = new Dictionary <string, IFCPhysicalQuantity>(); foreach (IFCAnyHandle quantity in quantities) { IFCPhysicalQuantity ifcPhysicalQuantity = IFCPhysicalQuantity.ProcessIFCPhysicalQuantity(quantity); if (ifcPhysicalQuantity != null) { m_IFCQuantities[ifcPhysicalQuantity.Name] = ifcPhysicalQuantity; } } } else { Importer.TheLog.LogMissingRequiredAttributeError(ifcElementQuantity, "Quantities", false); } }
/// <summary> /// Processes IfcObject attributes. /// </summary> /// <param name="ifcObject">The IfcObject handle.</param> protected override void Process(IFCAnyHandle ifcObject) { base.Process(ifcObject); m_ObjectType = IFCAnyHandleUtil.GetStringAttribute(ifcObject, "ObjectType"); HashSet <IFCAnyHandle> isDefinedByHandles = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcObject, "IsDefinedBy"); if (isDefinedByHandles != null) { IFCPropertySetDefinition.ResetCounters(); foreach (IFCAnyHandle isDefinedByHandle in isDefinedByHandles) { if (IFCAnyHandleUtil.IsSubTypeOf(isDefinedByHandle, IFCEntityType.IfcRelDefinesByProperties)) { ProcessIFCRelDefinesByProperties(isDefinedByHandle); } else if (IFCAnyHandleUtil.IsSubTypeOf(isDefinedByHandle, IFCEntityType.IfcRelDefinesByType)) { ProcessIFCRelDefinesByType(isDefinedByHandle); } else { IFCImportFile.TheLog.LogUnhandledSubTypeError(isDefinedByHandle, IFCEntityType.IfcRelDefines, false); } } } }
private void ProcessIFCCompositeCurve(IFCAnyHandle ifcCurve) { IList <IFCAnyHandle> segments = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcCurve, "Segments"); foreach (IFCAnyHandle segment in segments) { ProcessIFCCompositeCurveSegment(segment); } }
/// <summary> /// Adds items to a given shape handle. /// </summary> /// <param name="shape">The shape handle.</param> /// <param name="items">The items.</param> public static void AddItemsToShape(IFCAnyHandle shape, ICollection <IFCAnyHandle> items) { HashSet <IFCAnyHandle> repItemSet = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(shape, "Items"); foreach (IFCAnyHandle repItem in items) { repItemSet.Add(repItem); } IFCAnyHandleUtil.SetAttribute(shape, "Items", repItemSet); }
/// <summary> /// Processes IfcElement attributes. /// </summary> /// <param name="ifcElement">The IfcElement handle.</param> protected override void Process(IFCAnyHandle ifcElement) { base.Process(ifcElement); m_Tag = IFCAnyHandleUtil.GetStringAttribute(ifcElement, "Tag"); ICollection <IFCAnyHandle> hasOpenings = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcElement, "HasOpenings"); if (hasOpenings != null) { foreach (IFCAnyHandle hasOpening in hasOpenings) { IFCAnyHandle relatedOpeningElement = IFCAnyHandleUtil.GetInstanceAttribute(hasOpening, "RelatedOpeningElement"); if (IFCAnyHandleUtil.IsNullOrHasNoValue(relatedOpeningElement)) { continue; } IFCFeatureElementSubtraction opening = IFCFeatureElementSubtraction.ProcessIFCFeatureElementSubtraction(relatedOpeningElement); if (opening != null) { opening.VoidsElement = this; Openings.Add(opening); } } } // "HasPorts" is new to IFC2x2. // For IFC4, "HasPorts" has moved to IfcDistributionElement. We'll keep the check here, but we will only check it // if we are exporting before IFC4 or if we have an IfcDistributionElement handle. bool checkPorts = (IFCImportFile.TheFile.SchemaVersion > IFCSchemaVersion.IFC2x2) && (IFCImportFile.TheFile.SchemaVersion < IFCSchemaVersion.IFC4 || IFCAnyHandleUtil.IsSubTypeOf(ifcElement, IFCEntityType.IfcDistributionElement)); if (checkPorts) { ICollection <IFCAnyHandle> hasPorts = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcElement, "HasPorts"); if (hasPorts != null) { foreach (IFCAnyHandle hasPort in hasPorts) { IFCAnyHandle relatingPort = IFCAnyHandleUtil.GetInstanceAttribute(hasPort, "RelatingPort"); if (IFCAnyHandleUtil.IsNullOrHasNoValue(relatingPort)) { continue; } IFCPort port = IFCPort.ProcessIFCPort(relatingPort); if (port != null) { Ports.Add(port); } } } } }