Пример #1
0
        public static IFramingElement SetGeometry(this IFramingElement framingElement, ICurve curve)
        {
            IFramingElement clone = (IFramingElement)framingElement.GetShallowClone();

            clone.Location = curve.IClone();
            return(clone);
        }
 public static MaterialComposition MaterialComposition(this IFramingElement framingElement)
 {
     if (framingElement.Property == null)
     {
         Engine.Reflection.Compute.RecordError("The IFramingElement MaterialComposition could not be calculated as no Property has been assigned.");
         return(null);
     }
     return(framingElement.Property.IMaterialComposition());
 }
Пример #3
0
 public static double SolidVolume(this IFramingElement framingElement)
 {
     if (framingElement.Property == null)
     {
         Engine.Reflection.Compute.RecordError("The IFramingElement Solid Volume could not be calculated as no property has been assigned. Returning zero volume.");
         return(0);
     }
     return(framingElement.Location.Length() * IAverageProfileArea(framingElement.Property));
 }
Пример #4
0
        public static IGeometry Geometry3D(this IFramingElement framingElement)
        {
            if (framingElement == null)
            {
                BH.Engine.Reflection.Compute.RecordError("Cannot query the 3D Geometry of a null framing element.");
                return(null);
            }

            if (framingElement.Location == null)
            {
                BH.Engine.Reflection.Compute.RecordError($"Cannot compute the Geometry3D for this {nameof(IFramingElement)} because its `{nameof(IFramingElement.Location)}` is null.");
                return(null);
            }

            Line line = framingElement.Location as Line;

            if (line == null)
            {
                Polyline pl = framingElement.Location as Polyline;
                if (pl != null)
                {
                    line = new Line()
                    {
                        Start = pl.ControlPoints.First(), End = pl.ControlPoints.Last()
                    };
                }

                if (pl == null || (pl != null && pl.ControlPoints.Count() > 2))
                {
                    BH.Engine.Reflection.Compute.RecordWarning($"Geometry3D for {nameof(IFramingElement)} currently works only if it has its {nameof(IFramingElement.Location)} defined as a {nameof(Line)}. Proceeding by taking Start/End point of the provided {framingElement.Location.GetType().Name}.");
                }
            }

            Vector extrusionVec          = BH.Engine.Geometry.Create.Vector(line.Start, line.End);
            Vector normal                = line.ElementNormal(0);
            IFramingElementProperty prop = framingElement.Property;

            ConstantFramingProperty constantFramingProperty = prop as ConstantFramingProperty;

            if (constantFramingProperty == null)
            {
                BH.Engine.Reflection.Compute.RecordError($"Geometry3D for {nameof(IFramingElement)} currently works only if its {nameof(IFramingElement.Property)} is of type {nameof(ConstantFramingProperty)}.");
                return(null);
            }

            List <ICurve> profileToExtrude = constantFramingProperty.Profile.Edges.ToList();

            if (profileToExtrude == null || !profileToExtrude.Any())
            {
                BH.Engine.Reflection.Compute.RecordError($"Geometry3D error: could not gather the profile curve to be extruded for this {framingElement.GetType().Name}.");
                return(null);
            }

            TransformMatrix totalTransform = SectionTranformation(line.Start, extrusionVec.Normalise(), normal);

            return(Extrude(profileToExtrude, totalTransform, extrusionVec));
        }
Пример #5
0
        /***************************************************/

        internal static void FramingCurveNotFoundWarning(this IFramingElement framingElement)
        {
            string message = "Driving curve of a BHoM framing element could not be retrieved.";

            if (framingElement != null)
            {
                message = string.Format("{0} BHoM_Guid: {1}", message, framingElement.BHoM_Guid);
            }

            BH.Engine.Reflection.Compute.RecordWarning(message);
        }
Пример #6
0
        public static IFramingElement SetGeometry(this IFramingElement framingElement, ICurve curve)
        {
            if(framingElement == null)
            {
                BH.Engine.Reflection.Compute.RecordError("Cannot set the geometry of a null framing element.");
                return null;
            }

            IFramingElement clone = framingElement.ShallowClone();
            clone.Location = curve.DeepClone();
            return clone;
        }
Пример #7
0
        public static bool HasMergeablePropertiesWith(this IFramingElement element, IFramingElement other)
        {
            if (element == null || other == null)
            {
                return(false); //If either is null, then it can probably can't have its properties merged
            }
            if (element.GetType() != other.GetType())
            {
                return(false);
            }

            if (element.Location == null || element.Location.ILength() < oM.Geometry.Tolerance.Distance || other.Location == null || other.Location.ILength() < oM.Geometry.Tolerance.Distance)
            {
                return(false);
            }

            if (!element.Location.IIsLinear() || !other.Location.IIsLinear())
            {
                Engine.Reflection.Compute.RecordWarning("No merge comparison avalible for non-linear IFramingElements.");
                return(false);
            }

            int parallel = element.Location.IStartDir().IsParallel(other.Location.IStartDir());

            if (parallel != 1)
            {
                return(false);
            }

            if (element.Normal().Angle(other.Normal()) > BH.oM.Geometry.Tolerance.Angle)
            {
                return(false);
            }

            if (element.Property == other.Property)
            {
                return(true);
            }

            if (element.Property == null || other.Property == null)
            {
                return(false);
            }

            if (element.Property.Name != other.Property.Name)
            {
                return(false);
            }

            return(Diffing.Query.DifferentProperties(element.Property, other.Property, new DiffingConfig()) == null);
        }
Пример #8
0
        public static MaterialComposition MaterialComposition(this IFramingElement framingElement)
        {
            if (framingElement == null)
            {
                BH.Engine.Reflection.Compute.RecordError("Cannot query the material composition of a null framing element.");
                return(null);
            }

            if (framingElement.Property == null)
            {
                Engine.Reflection.Compute.RecordError("The MaterialComposition could not be queried as no Property has been assigned to the IFramingElement.");
                return(null);
            }
            return(framingElement.Property.IMaterialComposition());
        }
Пример #9
0
        public static Vector Normal(this IFramingElement framingElement)
        {
            double orientationAngle = 0;

            if (!(framingElement.Property is ConstantFramingProperty))
            {
                Reflection.Compute.RecordWarning("No ConstantFramingProperty found, OrientationAngle set as 0");
            }
            else
            {
                orientationAngle = (framingElement.Property as ConstantFramingProperty).OrientationAngle;
            }

            return(framingElement.Location.ElementNormal(orientationAngle));
        }
Пример #10
0
        /***************************************************/

        public static bool SetLocation(this FamilyInstance element, IFramingElement framingElement, RevitSettings settings)
        {
            if (!(typeof(IFramingElement).BuiltInCategories().Contains((BuiltInCategory)element.Category.Id.IntegerValue)))
            {
                return(false);
            }

            double rotation = 0;
            ConstantFramingProperty framingProperty = framingElement.Property as ConstantFramingProperty;

            if (framingProperty == null)
            {
                BH.Engine.Reflection.Compute.RecordWarning(String.Format("BHoM object's property is not a ConstantFramingProperty, therefore its orientation angle could not be retrieved. BHoM_Guid: {0}", framingElement.BHoM_Guid));
            }
            else
            {
                rotation = ((ConstantFramingProperty)framingElement.Property).OrientationAngle;
            }

            if (element.LookupParameterInteger(BuiltInParameter.YZ_JUSTIFICATION) == 1)
            {
                BH.Engine.Reflection.Compute.RecordWarning(String.Format("Pushing of framing elements with non-uniform offsets at ends is currently not supported. yz Justification parameter has been set to Uniform. Revit ElementId: {0}", element.Id));
                element.SetParameter(BuiltInParameter.YZ_JUSTIFICATION, 0);
                element.Document.Regenerate();
            }

            bool updated = element.SetLocation(framingElement.Location, settings);

            element.Document.Regenerate();

            double rotationDifference = element.OrientationAngleFraming(settings) - rotation;

            if (Math.Abs(rotationDifference) > settings.AngleTolerance)
            {
                double newRotation = (element.LookupParameterDouble(BuiltInParameter.STRUCTURAL_BEND_DIR_ANGLE) + rotationDifference).NormalizeAngleDomain();
                updated |= element.SetParameter(BuiltInParameter.STRUCTURAL_BEND_DIR_ANGLE, newRotation);
                element.Document.Regenerate();
            }

            ICurve transformedCurve = framingElement.AdjustedLocationCurveFraming((FamilyInstance)element, settings);

            updated |= element.SetLocation(transformedCurve, settings);

            return(updated);
        }
Пример #11
0
        /***************************************************/
        /****               Public Methods              ****/
        /***************************************************/

        public static bool SetType(this FamilyInstance element, IFramingElement bHoMObject, RevitSettings settings)
        {
            Document     doc          = element.Document;
            FamilySymbol familySymbol = bHoMObject.Property.ToRevitElementType(doc, bHoMObject.BuiltInCategories(doc), settings);

            if (familySymbol == null)
            {
                familySymbol = bHoMObject.IElementType(doc, settings) as FamilySymbol;
            }

            if (familySymbol == null)
            {
                Compute.ElementTypeNotFoundWarning(bHoMObject);
                return(false);
            }

            return(element.SetParameter(BuiltInParameter.ELEM_TYPE_PARAM, familySymbol.Id));
        }
Пример #12
0
        public static ICurve TopCentreline(this IFramingElement element)
        {
            if (element == null)
            {
                BH.Engine.Reflection.Compute.RecordError("Cannot query the top centreline of a null framing element.");
                return(null);
            }

            ICurve location = element.Location;

            Vector normal = null;

            try
            {
                normal = BH.Engine.Physical.Query.Normal(element);
            }
            catch
            {
                Engine.Reflection.Compute.RecordError("IFramingElement must have linear location line.");
                return(null);
            }

            if (normal == null)
            {
                Engine.Reflection.Compute.RecordError("Was not able to compute element normal.");
                return(null);
            }

            if (element.Property is ConstantFramingProperty)
            {
                ConstantFramingProperty constantProperty = element.Property as ConstantFramingProperty;

                IProfile profile = constantProperty.Profile;

                BoundingBox profileBounds = profile.Edges.Bounds();

                return(location.ITranslate(normal * profileBounds.Max.Y));
            }
            else
            {
                Engine.Reflection.Compute.RecordError("Element does not have a suitable framing property, so the section height could not be calculated.");
                return(null);
            }
        }
Пример #13
0
        public static double Elevation(this IFramingElement obj, ElevationFrom elevationFrom = ElevationFrom.MidPoint)
        {
            if (elevationFrom == ElevationFrom.MidPoint)
            {
                return(obj.Location.IPointAtParameter(0.5).Z);
            }

            if (elevationFrom == ElevationFrom.LowestPoint)
            {
                return(BH.Engine.CIH.Query.Points(obj.Location).OrderBy(p => p.Z).First().Z);
            }

            if (elevationFrom == ElevationFrom.HighestPoint)
            {
                return(BH.Engine.CIH.Query.Points(obj.Location).OrderBy(p => p.Z).Last().Z);
            }

            BH.Engine.Reflection.Compute.RecordError($"Could not compute the elevation of a {obj.GetType().Name}.");
            return(0);
        }
Пример #14
0
        public static ICurve BoundingBoxCentreline(this IFramingElement element)
        {
            ICurve location = element?.Location;

            if (location == null)
            {
                return(null);
            }

            Vector normal = null;

            normal = element.Normal();
            if (normal == null)
            {
                Engine.Reflection.Compute.RecordError("IFramingElement must have linear location line.");
                return(null);
            }

            Vector tangent = (location.IEndPoint() - location.IStartPoint()).Normalise();

            Vector localx = tangent.CrossProduct(normal);

            if (element.Property is ConstantFramingProperty)
            {
                Point centre = (element.Property as ConstantFramingProperty)?.Profile?.Edges?.Bounds()?.Centre();

                if (centre == null)
                {
                    return(null);
                }

                Vector sectionTranslate = centre - Point.Origin;

                return(location.ITranslate(-localx * sectionTranslate.X + normal * sectionTranslate.Y));
            }
            else
            {
                Engine.Reflection.Compute.RecordError("Only suitable framing property for the action is ConstantFramingProperty.");
                return(null);
            }
        }
Пример #15
0
        public static Vector Normal(this IFramingElement framingElement)
        {
            if (framingElement == null)
            {
                BH.Engine.Reflection.Compute.RecordError("Cannot query the normal of a null framing element.");
                return(null);
            }

            double orientationAngle = 0;

            if (!(framingElement.Property is ConstantFramingProperty))
            {
                Reflection.Compute.RecordWarning("No ConstantFramingProperty found, OrientationAngle set as 0");
            }
            else
            {
                orientationAngle = (framingElement.Property as ConstantFramingProperty).OrientationAngle;
            }

            return(framingElement.Location.ElementNormal(orientationAngle));
        }
Пример #16
0
        public static ICurve ZJustifiedCurve(this IFramingElement element)
        {
            if (element == null)
            {
                return(null);
            }

            string zJustification = element.GetRevitParameterValue("z Justification")?.ToString().ToLower();

            if (zJustification == "top")
            {
                return(element.TopCentreline());
            }
            else if (zJustification == "bottom")
            {
                return(element.BottomCentreline());
            }
            else if (zJustification == "center")
            {
                ICurve top    = element.TopCentreline();
                ICurve bottom = element.BottomCentreline();
                Point  start  = (top.IStartPoint() + bottom.IStartPoint()) * 0.5;
                Point  end    = (top.IEndPoint() + bottom.IEndPoint()) * 0.5;
                return(new Line {
                    Start = start, End = end
                });
            }
            else if (zJustification == "origin")
            {
                return(element.Location);
            }
            else
            {
                Engine.Reflection.Compute.RecordError("Error extracting z Justification Revit parameter, location curve of the BHoM object has been returned.");
                return(element.Location);
            }
        }
Пример #17
0
        public static IFramingElement Transform(this IFramingElement framingElement, TransformMatrix transform, double tolerance = Tolerance.Distance)
        {
            if (!transform.IsRigidTransformation(tolerance))
            {
                BH.Engine.Reflection.Compute.RecordError("Transformation failed: only rigid body transformations are currently supported.");
                return(null);
            }

            IFramingElement result = framingElement.ShallowClone();

            result.Location = result.Location.ITransform(transform);

            ConstantFramingProperty property = result.Property as ConstantFramingProperty;

            if (property == null)
            {
                BH.Engine.Reflection.Compute.RecordWarning($"Orientation angle of the IFramingElement has not been transformed because its property is not ConstantFramingProperty. BHoM_Guid: {framingElement.BHoM_Guid}");
            }
            else
            {
                if (framingElement.Location is Line)
                {
                    ConstantFramingProperty newProperty = property.ShallowClone();
                    Vector normalBefore = ((Line)framingElement.Location).ElementNormal(property.OrientationAngle);
                    Vector normalAfter  = normalBefore.Transform(transform);
                    newProperty.OrientationAngle = normalAfter.OrientationAngleLinear((Line)result.Location);
                    result.Property = newProperty;
                }
                else if (!framingElement.Location.IIsPlanar(tolerance))
                {
                    BH.Engine.Reflection.Compute.RecordWarning($"The element's location is a nonlinear, nonplanar curve. Correctness of orientation angle after transform could not be ensured in 100%. BHoM_Guid: {framingElement.BHoM_Guid}");
                }
            }

            return(result);
        }
Пример #18
0
 public static double Elevation(this IFramingElement obj)
 {
     return(Elevation(obj, ElevationFrom.MidPoint));
 }
Пример #19
0
 public static ICurve Geometry(this IFramingElement framingElement)
 {
     return(framingElement.Location);
 }
Пример #20
0
        /***************************************************/
        /****              Public methods               ****/
        /***************************************************/

        public static ICurve AdjustedLocationCurveFraming(this IFramingElement framingElement, FamilyInstance familyInstance, RevitSettings settings = null)
        {
            settings = settings.DefaultIfNull();

            ICurve curve = framingElement?.Location;

            if (curve == null || (!(curve is NurbsCurve) && curve.ILength() <= settings.DistanceTolerance))
            {
                framingElement.FramingCurveNotFoundWarning();
                return(null);
            }

            BH.oM.Geometry.Line line = curve as BH.oM.Geometry.Line;
            if (line == null)
            {
                familyInstance.NonLinearFramingOffsetWarning();
                return(curve);
            }

            Output <Vector, Vector> offsets = familyInstance.FramingOffsetVectors();
            Vector startOffset = -offsets.Item1;
            Vector endOffset   = -offsets.Item2;

            double startOffsetLength = startOffset.Length();
            double endOffsetLength   = endOffset.Length();

            if (startOffsetLength > settings.DistanceTolerance || endOffsetLength > settings.DistanceTolerance)
            {
                if ((startOffset - endOffset).Length() > settings.DistanceTolerance)
                {
                    BH.Engine.Reflection.Compute.RecordError(String.Format("Adjusted location curve of a Revit framing element could not be found because it has non-uniform offsets at ends. Revit ElementId: {0}", familyInstance.Id));
                    return(null);
                }

                Transform transform    = familyInstance.GetTotalTransform();
                Vector    yOffsetStart = new Vector {
                    X = transform.BasisY.X * startOffset.Y, Y = transform.BasisY.Y * startOffset.Y, Z = transform.BasisY.Z * startOffset.Y
                };
                Vector zOffsetStart = new Vector {
                    X = transform.BasisZ.X * startOffset.Z, Y = transform.BasisZ.Y * startOffset.Z, Z = transform.BasisZ.Z * startOffset.Z
                };
                Vector yOffsetEnd = new Vector {
                    X = transform.BasisY.X * endOffset.Y, Y = transform.BasisY.Y * endOffset.Y, Z = transform.BasisY.Z * endOffset.Y
                };
                Vector zOffsetEnd = new Vector {
                    X = transform.BasisZ.X * endOffset.Z, Y = transform.BasisZ.Y * endOffset.Z, Z = transform.BasisZ.Z * endOffset.Z
                };
                line = new BH.oM.Geometry.Line {
                    Start = line.Start.Translate(yOffsetStart + zOffsetStart), End = line.End.Translate(yOffsetEnd + zOffsetEnd)
                };
            }

            Vector dir            = line.Direction();
            double startExtension = familyInstance.LookupParameterDouble(BuiltInParameter.START_EXTENSION);

            if (!double.IsNaN(startExtension))
            {
                line.Start = line.Start + dir * startExtension;
            }

            double endExtension = familyInstance.LookupParameterDouble(BuiltInParameter.END_EXTENSION);

            if (!double.IsNaN(endExtension))
            {
                line.End = line.End - dir * endExtension;
            }

            return(line);
        }
Пример #21
0
        public static List <IFramingElement> ConfigureAgainstSpecifications(HashSet <IFramingElement> objs, List <Specification> specifications)
        {
            List <IFramingElement> res = new List <IFramingElement>();
            List <string>          valueCondPropName = new List <string>();

            // Only use specifications that are "applied" Zone Specifications.
            var appliedZoneSpecs = specifications.Where(s => s.IsAppliedZoneSpec()).ToList();

            if (appliedZoneSpecs.Count == 0)
            {
                BH.Engine.Reflection.Compute.RecordError($"No Applied Zone Specification found. The input Zone specifications do not have any {nameof(IsInZone)} condition, or do not have their {nameof(IsInZone.ClosedVolumes)} populated.");
                return(new List <IFramingElement>());
            }

            Dictionary <object, List <IFramingElement> > compatibleObjsPerZone = new Dictionary <object, List <IFramingElement> >();

            foreach (var spec in appliedZoneSpecs)
            {
                // Remove any IsInZone condition from the specs.
                // The kit of parts objects are just "archetypes" - not placed in a meaningful location of the model space.
                Specification specCopy = spec.DeepClone();

                specCopy.FilterConditions.RemoveAll(fc => fc is IsInZone);
                specCopy.CheckConditions.RemoveAll(fc => fc is IsInZone);

                // The Part of the Kit (object archetype) must be moved in its final location,
                // so we can make sure that all other conditions can be evaluated on the actual object.
                // e.g. if there are conditions - that are not IsInZone - that are based on position properties.
                var          allClosedVolumes     = spec.FilterConditions.OfType <IsInZone>().SelectMany(c => c.ClosedVolumes);
                List <Point> closedVolumesCentres = allClosedVolumes.Select(cv => cv.IBounds().Centre()).ToList();

                closedVolumesCentres = BH.Engine.Geometry.Compute.CullDuplicates(closedVolumesCentres.ToList());


                foreach (var pt in closedVolumesCentres)
                {
                    foreach (var obj in objs)
                    {
                        compatibleObjsPerZone[pt] = compatibleObjsPerZone.ContainsKey(pt) ? compatibleObjsPerZone[pt] : new List <IFramingElement>();

                        ICurve geom       = obj.Location;
                        var    moveVector = BH.Engine.Geometry.Create.Vector(geom.IBounds().Centre(), pt);

                        var movedGeom = BH.Engine.Geometry.Modify.ITranslate(geom, moveVector);

                        IFramingElement objCopy = obj.DeepClone();
                        objCopy.Location = movedGeom;

                        var specRes = VerifySpecification(new List <object>()
                        {
                            objCopy
                        }, specCopy);
                        if (specRes.PassedObjects.Count != 1)
                        {
                            continue;
                        }

                        valueCondPropName.AddRange(spec.CheckConditions.OfType <IValueCondition>().Select(c => c.PropertyName));

                        compatibleObjsPerZone[pt].Add(objCopy);
                    }
                }
            }

            List <IFramingElement> result = new List <IFramingElement>();

            foreach (var kv in compatibleObjsPerZone)
            {
                var ordered = kv.Value.OrderBy(v => v.ValueFromSource("Property.IAverageProfileArea")).ToList();

                if (ordered.FirstOrDefault() != null)
                {
                    result.Add(ordered.FirstOrDefault());
                }
            }


            return(result);
        }
Пример #22
0
        /***************************************************/
        /**** Public Methods                            ****/
        /***************************************************/

        // Configure to Order workflow.
        public static List <IFramingElement> ConfigureAgainstSpecifications(HashSet <IFramingElement> objs, List <Specification> specifications, bool sortDirection = true)
        {
            if (!previousSet.Any())
            {
                previousSet = objs;
            }

            if (!previousSet.Intersect(objs).Any())
            {
                return(previousConfig);
            }

            // Override hack.
            previousConfig = ConfigureAgainstSpecifications(objs, specifications);
            return(previousConfig);

            List <IFramingElement> result = new List <IFramingElement>();

            List <Specification> compatibleSpecs = new List <Specification>();
            var compatibleObject = CompatibleObjects(objs, specifications, out compatibleSpecs, 1, sortDirection).FirstOrDefault();

            if (compatibleObject == null)
            {
                return(new List <IFramingElement>());
            }

            var appliedZoneSpecs = specifications.Where(s => s.IsAppliedZoneSpec());

            List <Point> allDistinctClosedVolumeCentres = new List <Point>();

            foreach (var spec in compatibleSpecs)
            {
                var          allClosedVolumes     = spec.FilterConditions.OfType <IsInZone>().SelectMany(c => c.ClosedVolumes);
                List <Point> closedVolumesCentres = allClosedVolumes.Select(cv => cv.IBounds().Centre()).ToList();

                closedVolumesCentres = BH.Engine.Geometry.Compute.CullDuplicates(closedVolumesCentres.ToList());

                foreach (var pt in closedVolumesCentres)
                {
                    allDistinctClosedVolumeCentres.Add(pt);
                }
            }

            allDistinctClosedVolumeCentres = BH.Engine.Geometry.Compute.CullDuplicates(allDistinctClosedVolumeCentres);

            foreach (var pt in allDistinctClosedVolumeCentres)
            {
                // The object satisfied this spec.
                // Move the object into the "location of this spec".
                ICurve geom       = compatibleObject.Location;
                var    moveVector = BH.Engine.Geometry.Create.Vector(geom.IBounds().Centre(), pt);

                var movedGeom = BH.Engine.Geometry.Modify.ITranslate(geom, moveVector);

                IFramingElement objCopy = compatibleObject.DeepClone();
                objCopy.Location = movedGeom;

                result.Add(objCopy);
            }

            return(result.Distinct().ToList());
        }
Пример #23
0
        public static List <IFramingElement> CompatibleObjects(HashSet <IFramingElement> objects, List <Specification> specifications, out List <Specification> compatibleSpecs, int limit = 1, bool sortDirection = true)
        {
            List <IFramingElement> res = new List <IFramingElement>();

            compatibleSpecs = new List <Specification>();
            List <string> valueCondPropName = new List <string>();

            // Only use specifications that are "applied" Zone Specifications.
            var appliedZoneSpecs = specifications.Where(s => s.IsAppliedZoneSpec()).ToList();

            if (appliedZoneSpecs.Count == 0)
            {
                BH.Engine.Reflection.Compute.RecordError($"No Applied Zone Specification found. The input Zone specifications do not have any {nameof(IsInZone)} condition, or do not have their {nameof(IsInZone.ClosedVolumes)} populated.");
                return(new List <IFramingElement>());
            }

            foreach (var obj in objects)
            {
                foreach (var spec in appliedZoneSpecs)
                {
                    // Remove any IsInZone condition from the specs.
                    // The kit of parts objects are just "archetypes" - not placed in a meaningful location of the model space.
                    Specification specCopy = spec.DeepClone();

                    specCopy.FilterConditions.RemoveAll(fc => fc is IsInZone);
                    specCopy.CheckConditions.RemoveAll(fc => fc is IsInZone);

                    // The Part of the Kit (object archetype) must be moved in its final location,
                    // so we can make sure that all other conditions can be evaluated on the actual object.
                    // e.g. if there are conditions - that are not IsInZone - that are based on position properties.
                    var          allClosedVolumes     = spec.FilterConditions.OfType <IsInZone>().SelectMany(c => c.ClosedVolumes);
                    List <Point> closedVolumesCentres = allClosedVolumes.Select(cv => cv.IBounds().Centre()).ToList();

                    closedVolumesCentres = BH.Engine.Geometry.Compute.CullDuplicates(closedVolumesCentres.ToList());

                    foreach (var pt in closedVolumesCentres)
                    {
                        ICurve geom       = obj.Location;
                        var    moveVector = BH.Engine.Geometry.Create.Vector(geom.IBounds().Centre(), pt);

                        var movedGeom = BH.Engine.Geometry.Modify.ITranslate(geom, moveVector);

                        IFramingElement objCopy = obj.DeepClone();
                        objCopy.Location = movedGeom;

                        var specRes = VerifySpecification(new List <object>()
                        {
                            objCopy
                        }, specCopy);
                        if (specRes.PassedObjects.Count != 1)
                        {
                            continue;
                        }

                        valueCondPropName.AddRange(spec.CheckConditions.OfType <IValueCondition>().Select(c => c.PropertyName));

                        res.Add(obj);
                        compatibleSpecs.Add(spec);
                    }
                }
            }

            res = res.Distinct().ToList();
            valueCondPropName = valueCondPropName.Distinct().ToList();
            compatibleSpecs   = compatibleSpecs.Distinct().ToList();

            if (valueCondPropName.Count == 1)
            {
                res = res.OrderBy(obj => obj.ValueFromSource(valueCondPropName.First())).ToList();
            }

            if (!sortDirection)
            {
                res.Reverse();
            }

            if (res.Count() == 0)
            {
                BH.Engine.Reflection.Compute.RecordWarning("No compatible object found.");
                return(new List <IFramingElement>());
            }

            return(res.Take(limit).ToList());
        }
Пример #24
0
        /***************************************************/

        public static FamilyInstance ToRevitFamilyInstance(this IFramingElement framingElement, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
        {
            if (framingElement == null || document == null)
            {
                return(null);
            }

            FamilyInstance familyInstance = refObjects.GetValue <FamilyInstance>(document, framingElement.BHoM_Guid);

            if (familyInstance != null)
            {
                return(familyInstance);
            }

            settings = settings.DefaultIfNull();

            if (framingElement.Location == null)
            {
                BH.Engine.Reflection.Compute.RecordError(String.Format("Revit element could not be created because the driving curve of a BHoM object is null. BHoM_Guid: {0}", framingElement.BHoM_Guid));
                return(null);
            }

            if (!framingElement.Location.IIsPlanar())
            {
                BH.Engine.Reflection.Compute.RecordError(string.Format("Revit framing does only support planar curves, element could not be created. BHoM_Guid: {0}", framingElement.BHoM_Guid));
                return(null);
            }

            Curve revitCurve = framingElement.Location.IToRevit();

            if (revitCurve == null)
            {
                BH.Engine.Reflection.Compute.RecordError(string.Format("Revit element could not be created because of curve conversion issues. BHoM_Guid: {0}", framingElement.BHoM_Guid));
                return(null);
            }

            Level level = document.LevelBelow(framingElement.Location, settings);

            FamilySymbol familySymbol = framingElement.Property.ToRevitElementType(document, framingElement.BuiltInCategories(document), settings, refObjects);

            if (familySymbol == null)
            {
                familySymbol = framingElement.ElementType(document, settings) as FamilySymbol;
            }

            if (familySymbol == null)
            {
                Compute.ElementTypeNotFoundWarning(framingElement);
                return(null);
            }

            FamilyPlacementType familyPlacementType = familySymbol.Family.FamilyPlacementType;

            if (familyPlacementType != FamilyPlacementType.CurveBased && familyPlacementType != FamilyPlacementType.CurveBasedDetail && familyPlacementType != FamilyPlacementType.CurveDrivenStructural && familyPlacementType != FamilyPlacementType.TwoLevelsBased)
            {
                Compute.InvalidFamilyPlacementTypeError(framingElement, familySymbol);
                return(null);
            }

            if (framingElement is Beam)
            {
                familyInstance = document.Create.NewFamilyInstance(revitCurve, familySymbol, level, Autodesk.Revit.DB.Structure.StructuralType.Beam);
            }
            else if (framingElement is Bracing || framingElement is Cable)
            {
                familyInstance = document.Create.NewFamilyInstance(revitCurve, familySymbol, level, Autodesk.Revit.DB.Structure.StructuralType.Brace);
            }
            else
            {
                familyInstance = document.Create.NewFamilyInstance(revitCurve, familySymbol, level, Autodesk.Revit.DB.Structure.StructuralType.UnknownFraming);
            }

            document.Regenerate();

            familyInstance.CheckIfNullPush(framingElement);
            if (familyInstance == null)
            {
                return(null);
            }

            oM.Physical.FramingProperties.ConstantFramingProperty barProperty = framingElement.Property as oM.Physical.FramingProperties.ConstantFramingProperty;
            if (barProperty != null)
            {
                //TODO: if the material does not get assigned an error should be thrown?
                if (barProperty.Material != null)
                {
                    Material material = document.GetElement(new ElementId(BH.Engine.Adapters.Revit.Query.ElementId(barProperty.Material))) as Material;
                    if (material != null)
                    {
                        Parameter param = familyInstance.get_Parameter(BuiltInParameter.STRUCTURAL_MATERIAL_PARAM);
                        if (param != null && param.HasValue && !param.IsReadOnly)
                        {
                            familyInstance.StructuralMaterialId = material.Id;
                        }
                        else
                        {
                            BH.Engine.Reflection.Compute.RecordWarning(string.Format("The BHoM material has been correctly converted, but the property could not be assigned to the Revit element. ElementId: {0}", familyInstance.Id));
                        }
                    }
                }
            }

            //Set the insertion point to centroid.
            Parameter zJustification = familyInstance.get_Parameter(BuiltInParameter.Z_JUSTIFICATION);

            if (zJustification != null && !zJustification.IsReadOnly)
            {
                zJustification.Set((int)Autodesk.Revit.DB.Structure.ZJustification.Origin);
            }

            familyInstance.CopyParameters(framingElement, settings);
            familyInstance.SetLocation(framingElement, settings);

            if (familyInstance.StructuralMaterialType != StructuralMaterialType.Concrete && familyInstance.StructuralMaterialType != StructuralMaterialType.PrecastConcrete)
            {
                StructuralFramingUtils.DisallowJoinAtEnd(familyInstance, 0);
                StructuralFramingUtils.DisallowJoinAtEnd(familyInstance, 1);
            }

            refObjects.AddOrReplace(framingElement, familyInstance);
            return(familyInstance);
        }
Пример #25
0
        /***************************************************/
        /****            Interface methods              ****/
        /***************************************************/

        public static FamilyInstance IToRevitFamilyInstance(this IFramingElement framingElement, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
        {
            return(ToRevitFamilyInstance(framingElement as dynamic, document, settings, refObjects));
        }