/// <summary>
        /// Return geometry for a particular representation item.
        /// </summary>
        /// <param name="shapeEditScope">The shape edit scope.</param>
        /// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
        /// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
        /// <param name="guid">The guid of an element for which represntation is being created.</param>
        /// <returns>Zero or more created geometries.</returns>
        public IList<GeometryObject> CreateGeometry(IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
        {
            if (StyledByItem != null)
                StyledByItem.Create(shapeEditScope);

            using (IFCImportShapeEditScope.IFCMaterialStack stack = new IFCImportShapeEditScope.IFCMaterialStack(shapeEditScope, StyledByItem, null))
            {
                return CreateGeometryInternal(shapeEditScope, lcs, scaledLcs, guid);
            }
        }
        /// <summary>
        /// Create geometry for a particular representation item.
        /// </summary>
        /// <param name="shapeEditScope">The geometry creation scope.</param>
        /// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
        /// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
        /// <param name="guid">The guid of an element for which represntation is being created.</param>
        public void CreateShape(IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
        {
            if (StyledByItem != null)
                StyledByItem.Create(shapeEditScope);

            if (LayerAssignment != null)
                LayerAssignment.Create(shapeEditScope);
            
            using (IFCImportShapeEditScope.IFCMaterialStack stack = new IFCImportShapeEditScope.IFCMaterialStack(shapeEditScope, StyledByItem, LayerAssignment))
            {
                CreateShapeInternal(shapeEditScope, lcs, scaledLcs, guid);
            }
        }
      /// <summary>
      /// Return geometry for a particular representation item.
      /// </summary>
      /// <param name="shapeEditScope">The geometry creation scope.</param>
      /// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
      /// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
      /// <param name="guid">The guid of an element for which represntation is being created.</param>
      /// <returns>The created geometry.</returns>
      public IList<GeometryObject> CreateGeometry(
            IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
      {
         IList<GeometryObject> firstSolids = FirstOperand.CreateGeometry(shapeEditScope, lcs, scaledLcs, guid);

         if (firstSolids != null)
         {
            foreach (GeometryObject potentialSolid in firstSolids)
            {
               if (!(potentialSolid is Solid))
               {
                  Importer.TheLog.LogError((FirstOperand as IFCRepresentationItem).Id, "Can't perform Boolean operation on a Mesh.", false);
                  return firstSolids;
               }
            }
         }

         IList<GeometryObject> secondSolids = null;
         if (SecondOperand != null)
         {
            try
            {
               using (IFCImportShapeEditScope.BuildPreferenceSetter setter =
                   new IFCImportShapeEditScope.BuildPreferenceSetter(shapeEditScope, IFCImportShapeEditScope.BuildPreferenceType.ForceSolid))
               {
                  // Before we process the second operand, we are going to see if there is a uniform material set for the first operand 
                  // (corresponding to the solid in the Boolean operation).  We will try to suggest the same material for the voids to avoid arbitrary
                  // setting of material information for the cut faces.
                  IFCStyledItem firstOperandStyledItem = GetStyledItemFromOperand(FirstOperand as IFCRepresentationItem);
                  using (IFCImportShapeEditScope.IFCMaterialStack stack =
                      new IFCImportShapeEditScope.IFCMaterialStack(shapeEditScope, firstOperandStyledItem, null))
                  {
                     secondSolids = SecondOperand.CreateGeometry(shapeEditScope, lcs, scaledLcs, guid);
                  }
               }
            }
            catch (Exception ex)
            {
               // We will allow something to be imported, in the case where the second operand is invalid.
               // If the first (base) operand is invalid, we will still fail the import of this solid.
               if (SecondOperand is IFCRepresentationItem)
                  Importer.TheLog.LogError((SecondOperand as IFCRepresentationItem).Id, ex.Message, false);
               else
                  throw ex;
               secondSolids = null;
            }
         }

         IList<GeometryObject> resultSolids = null;
         if (firstSolids == null)
         {
            resultSolids = secondSolids;
         }
         else if (secondSolids == null || BooleanOperator == null)
         {
            if (BooleanOperator == null)
               Importer.TheLog.LogError(Id, "Invalid BooleanOperationsType.", false);
            resultSolids = firstSolids;
         }
         else
         {
            BooleanOperationsType booleanOperationsType = BooleanOperationsType.Difference;
            switch (BooleanOperator)
            {
               case IFCBooleanOperator.Difference:
                  booleanOperationsType = BooleanOperationsType.Difference;
                  break;
               case IFCBooleanOperator.Intersection:
                  booleanOperationsType = BooleanOperationsType.Intersect;
                  break;
               case IFCBooleanOperator.Union:
                  booleanOperationsType = BooleanOperationsType.Union;
                  break;
               default:
                  Importer.TheLog.LogError(Id, "Invalid BooleanOperationsType.", true);
                  break;
            }

            resultSolids = new List<GeometryObject>();
            foreach (GeometryObject firstSolid in firstSolids)
            {
               Solid resultSolid = (firstSolid as Solid);

               int secondId = (SecondOperand == null) ? -1 : (SecondOperand as IFCRepresentationItem).Id;
               XYZ suggestedShiftDirection = (SecondOperand == null) ? null : SecondOperand.GetSuggestedShiftDirection(lcs);
               foreach (GeometryObject secondSolid in secondSolids)
               {
                  resultSolid = IFCGeometryUtil.ExecuteSafeBooleanOperation(Id, secondId, resultSolid, secondSolid as Solid, booleanOperationsType, suggestedShiftDirection);
                  if (resultSolid == null)
                     break;
               }

               if (resultSolid != null)
                  resultSolids.Add(resultSolid);
            }
         }

         return resultSolids;
      }
Ejemplo n.º 4
0
        /// <summary>
        /// Create geometry for a particular representation.
        /// </summary>
        /// <param name="shapeEditScope">The geometry creation scope.</param>
        /// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
        /// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
        /// <param name="guid">The guid of an element for which represntation is being created.</param>
        public void CreateShape(IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
        {
            // We are not yet displaying Axis information, but do (potentially) need the Axis curve for generating material layer-based extrusions.
            if (Identifier == IFCRepresentationIdentifier.Axis)
                return;

            if (LayerAssignment != null)
                LayerAssignment.Create(shapeEditScope);

            // There is an assumption here that Process() weeded out any items that are invalid for this representation.
            using (IFCImportShapeEditScope.IFCMaterialStack stack = new IFCImportShapeEditScope.IFCMaterialStack(shapeEditScope, null, LayerAssignment))
            {
                using (IFCImportShapeEditScope.IFCContainingRepresentationSetter repSetter = new IFCImportShapeEditScope.IFCContainingRepresentationSetter(shapeEditScope, this))
                {
                    foreach (IFCRepresentationItem representationItem in RepresentationItems)
                    {
                        using (IFCImportShapeEditScope.IFCTargetSetter setter =
                            new IFCImportShapeEditScope.IFCTargetSetter(shapeEditScope, TessellatedShapeBuilderTarget.AnyGeometry, TessellatedShapeBuilderFallback.Mesh))
                        {
                            representationItem.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Create geometry for a particular representation.
        /// </summary>
        /// <param name="shapeEditScope">The geometry creation scope.</param>
        /// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
        /// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
        /// <param name="guid">The guid of an element for which represntation is being created.</param>
        public void CreateShape(IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
        {
            // Special handling for Box representation.  We may decide to create an IFCBoundingBox class and stop this special treatment.
            if (Identifier == IFCRepresentationIdentifier.Box)
            {
                CreateBoxShape(shapeEditScope, scaledLcs);
                return;
            }

            if (LayerAssignment != null)
                LayerAssignment.Create(shapeEditScope);

            // There is an assumption here that Process() weeded out any items that are invalid for this representation.
            using (IFCImportShapeEditScope.IFCMaterialStack stack = new IFCImportShapeEditScope.IFCMaterialStack(shapeEditScope, null, LayerAssignment))
            {
                using (IFCImportShapeEditScope.IFCContainingRepresentationSetter repSetter = new IFCImportShapeEditScope.IFCContainingRepresentationSetter(shapeEditScope, this))
                {
                    foreach (IFCRepresentationItem representationItem in RepresentationItems)
                    {
                        representationItem.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
                    }
                }
            }
        }