Structure_Engine: Add engine methods for foundation classes

Geometry_Engine/Compute/GrahamScan.cs

@@ -0,0 +1,141 @@
+/*
+ * This file is part of the Buildings and Habitats object Model (BHoM)
+ * Copyright (c) 2015 - 2023, the respective contributors. All rights reserved.
+ *
+ * Each contributor holds copyright over their respective contributions.
+ * The project versioning (Git) records all such contribution source information.
+ *                                           
+ *                                                                              
+ * The BHoM is free software: you can redistribute it and/or modify         
+ * it under the terms of the GNU Lesser General Public License as published by  
+ * the Free Software Foundation, either version 3.0 of the License, or          
+ * (at your option) any later version.                                          
+ *                                                                              
+ * The BHoM is distributed in the hope that it will be useful,              
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 
+ * GNU Lesser General Public License for more details.                          
+ *                                                                            
+ * You should have received a copy of the GNU Lesser General Public License     
+ * along with this code. If not, see <https://www.gnu.org/licenses/lgpl-3.0.html>.      
+ */
+
+using BH.oM.Geometry;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.ComponentModel;
+using BH.oM.Base.Attributes;
+using BH.Engine.Base;
+using BH.Engine.Geometry;
+
+namespace BH.Engine.Geometry
+{
+    public static partial class Compute
+    {
+        /***************************************************/
+        /**** Public Methods                            ****/
+        /***************************************************/
+
+        [Description("Implements the GrahamScan algorithim to determine the convex hull of a list of points.")]
+        [Input("pts", "The points to determine the convex hull.")]
+        [Output("c", "The convex hull of the point list.")]
+        public static List<Point> GrahamScan(List<Point> pts)
+        {
+            if (pts.IsNullOrEmpty())
+            {
+                Base.Compute.RecordError("The point list is null or empty.");
+                return null;
+            }
+
+            // Find the point with the lowest Y coordination
+            IOrderedEnumerable<Point> orderedPts = pts.OrderBy(pt => pt.Y);
+
+            Point p = pts.First();
+
+            // Check if there is more than one point with the lowest Y
+            if (Math.Abs(p.Y - pts[1].Y) < Tolerance.MicroDistance)
+            {
+                // Get points with lowest Y coordinate and select the point with the lowest X
+                pts = orderedPts.ThenBy(x => x.X).ToList();
+                p = pts.First();
+            }
+            else
+                pts = orderedPts.ToList();
+
+            // Remove the P from the list of points
+            pts.Remove(p);
+
+            // Sort by the increasing order of the angle the point and P make with the x-axis
+            pts = pts.OrderBy(pt => Math.Atan2(pt.Y - p.Y, pt.X - p.X)).ToList(); // TODO: If several points have the same angle - break ties by increasing distance
+
+            // Group by angle between P and the points
+            IEnumerable<IGrouping<double,Point>> groupedPts = pts.GroupBy(pt => Math.Atan2(pt.Y - p.Y, pt.X - p.X));
+
+            // Add to the start of selPts as it has been removed from pts
+            List<Point> selPts = new List<Point>() { p };
+
+            bool duplicateAngle = false;
+
+            // Check for points that have the same angle 
+            if (groupedPts.Where(grp => grp.Count() > 1).Any())
+            {
+                // For each group, sort by distance from P and select the furthest point
+                pts = groupedPts.Select(g => new { s = g.OrderByDescending(i => i.Distance(p)) }).Select(x => x.s.First()).ToList();
+                duplicateAngle = true;
+            }
+
+            // Iterate through the algorithim
+            while (pts.Count > 0)
+            {
+                GrahamScanInt(ref pts, ref selPts);
+            };
+
+            // Due to the grouping, it is necessary to add the first point to close the polyline
+            if (duplicateAngle)
+                selPts.Add(selPts.First());
+
+            return selPts;
+        }
+
+        private static List<Point> GrahamScanInt(ref List<Point> pts, ref List<Point> selPts)
+        {
+            if (pts.Count > 0)
+            {
+                // Update the reference as the method moves along the curve
+                var p = pts[0];
+
+                // Add the next point along, needs a minimum of two points to begin (the third coming from p)
+                if (selPts.Count <= 1)
+                {
+                    selPts.Add(p);
+                    pts.RemoveAt(0);
+                }
+                else
+                {
+                    Point pt1 = selPts[selPts.Count - 1];
+                    Point pt2 = selPts[selPts.Count - 2];
+                    Vector dir1 = pt1 - pt2;
+                    Vector dir2 = p - pt1;
+
+                    if (Query.CrossProduct(dir1, dir2).Z < 0)
+                    {
+                        // Less than zero, therefore clockwise and the point is within the boundary
+                        selPts.RemoveAt(selPts.Count - 1);
+                    }
+                    else
+                    {
+                        // Greater than zero, therefore anticlockwise - so point is not within the boundary
+                        selPts.Add(p);
+                        pts.RemoveAt(0);
+                    }
+                }
+            }
+            return selPts;
+        }
+    }
+}
+
+
+
+

Structure_Engine/Create/Elements/PadFoundation.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.ComponentModel;
+using BH.oM.Base.Attributes;
+using BH.oM.Geometry;
+using BH.oM.Spatial.ShapeProfiles;
+using BH.oM.Structure.Elements;
+using BH.oM.Structure.SurfaceProperties;
+using BH.Engine.Base;
+using BH.Engine.Geometry;
+
+
+namespace BH.Engine.Structure
+{
+    public static partial class Create
+    {
+        /***************************************************/
+        /**** Public Methods                            ****/
+        /***************************************************/
+
+        [Description("Creates a PadFoundation from its fundamental parts and a basis.")]
+        [Input("profile", "The section profile defining the edges of the pad. All section constants are derived based on the dimensions of this.")]
+        [InputFromProperty("property")]
+        [Input("coordinates", "The Cartesian coordinate system to control the position and orientation of the PadFoundation.")]
+        public static PadFoundation PadFoundation(List<Edge> topSurface, ISurfaceProperty property = null, Basis orientation = null)
+        {
+            if (topSurface.IsNullOrEmpty() || topSurface.Any(x => x.IsNull()))
+                return null;
+
+            if (orientation == null)
+                orientation = new Basis(new Vector() { X = 1 }, new Vector() { Y = 1 }, new Vector() { Z = 1 });
+
+            return new PadFoundation() { TopSurface = topSurface, Property = property, Orientation = orientation };
+        }
+
+        /***************************************************/
+
+        [Description("Creates a PadFoundation from its fundamental parts and a basis.")]
+        [Input("width", "The width of the PadFoundation aligned with Global X.")]
+        [Input("length", "The length of the PadFoundation aligned with Global Y.")]
+        [InputFromProperty("property")]
+        [Input("coordinates", "The Cartesian coordinate system to control the position and orientation of the PadFoundation.")]
+        public static PadFoundation PadFoundation(double width, double length, ConstantThickness thickness, Basis orientation)
+        {
+            List<Edge> edges = Spatial.Create.RectangleProfile(length, width).Edges.Select(x => new Edge() { Curve = x }).ToList();
+
+            return PadFoundation(edges, thickness, orientation);
+        }
+    }
+}

Structure_Engine/Create/Elements/PileFoundaton.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.ComponentModel;
+using BH.oM.Base.Attributes;
+using BH.oM.Geometry;
+using BH.oM.Structure.Elements;
+using BH.oM.Structure.SurfaceProperties;
+using BH.Engine.Geometry;
+
+
+namespace BH.Engine.Structure
+{
+    public static partial class Create
+    {
+        /***************************************************/
+        /**** Public Methods                            ****/
+        /***************************************************/
+
+        [Description("Creates a structural PileFoundation from a pile cap and pile groups.")]
+        [Input("pileCap", "The pile cap defining the outer edge of the PileFoundation and location in 3D.")]
+        [Input("pileGroups", "Groups of piles contained within the outline of the pile cap.")]
+        public static PileFoundation PileFoundation(PadFoundation pileCap, List<PileGroup> pileGroups)
+        {
+            return new PileFoundation() { PileCap = pileCap, PileGroups = pileGroups };
+        }
+
+        /***************************************************/
+
+        [Description("Creates a structural PileFoundation from the pile groups, an offset and the PileCap properties.")]
+        [Input("pileGroups", "Groups of piles used to define the outline of the PileCap.")]
+        [InputFromProperty("property")]
+        [Input("offset", "The offset from the centre of the piles to the edge of the PileCap.")]
+        [Input("coordinates", "The Cartesian coordinate system to control the position and orientation of the PadFoundation.")]
+        public static PileFoundation PileFoundation(List<PileGroup> pileGroups, ConstantThickness property, double offset, Basis orientation)
+        {
+            List<Point> pts = new List<Point>();
+
+            foreach (PileGroup pileGroup in pileGroups)
+            {
+                pts.AddRange(pileGroup.PileLayout.Points);
+            }
+
+            pts.Add(pts.First());
+
+            List<Edge> edges = new List<Edge>() { new Edge() { Curve = Geometry.Create.Polyline(Geometry.Compute.GrahamScan(pts)).Offset(offset) } };
+
+            return new PileFoundation() { PileCap = PadFoundation(edges, property, orientation), PileGroups = pileGroups };
+        }
+
+        /***************************************************/
+
+    }
+}

Structure_Engine/Create/Elements/PileGroup.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.ComponentModel;
+using BH.oM.Base.Attributes;
+using BH.oM.Spatial.Layouts;
+using BH.oM.Structure.Elements;
+using BH.oM.Structure.SectionProperties;
+
+namespace BH.Engine.Structure
+{
+    public static partial class Create
+    {
+        /***************************************************/
+        /**** Public Methods                            ****/
+        /***************************************************/
+
+        [Description("Creates a structural PileGroup defining a group of piles with the same length and section. The object is used with a PileFoundation whereby the PileCap defines the location and orientation.")]
+        [Input("pileLength", "The length of the piles within the group.")]
+        [InputFromProperty("sectionProperty")]
+        [Input("pileLayout", "Pile Layout defining the position of the piles about the World Origin.")]
+        public static PileGroup PileGroup(double pileLength, ISectionProperty pileSection, ExplicitLayout pileLayout)
+        {
+            return new PileGroup() { PileLength = pileLength, PileSection = pileSection, PileLayout = pileLayout };
+        }
+
+        /***************************************************/
+
+    }
+}

Structure_Engine/Modify/SetOutlineElements1D.cs

@@ -0,0 +1,65 @@
+/*
+ * This file is part of the Buildings and Habitats object Model (BHoM)
+ * Copyright (c) 2015 - 2023, the respective contributors. All rights reserved.
+ *
+ * Each contributor holds copyright over their respective contributions.
+ * The project versioning (Git) records all such contribution source information.
+ *                                           
+ *                                                                              
+ * The BHoM is free software: you can redistribute it and/or modify         
+ * it under the terms of the GNU Lesser General Public License as published by  
+ * the Free Software Foundation, either version 3.0 of the License, or          
+ * (at your option) any later version.                                          
+ *                                                                              
+ * The BHoM is distributed in the hope that it will be useful,              
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 
+ * GNU Lesser General Public License for more details.                          
+ *                                                                            
+ * You should have received a copy of the GNU Lesser General Public License     
+ * along with this code. If not, see <https://www.gnu.org/licenses/lgpl-3.0.html>.      
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.ComponentModel;
+using BH.oM.Base.Attributes;
+using BH.oM.Dimensional;
+using BH.oM.Geometry;
+using BH.oM.Structure.Elements;
+using BH.Engine.Geometry;
+using BH.Engine.Base;
+
+
+namespace BH.Engine.Structure
+{
+    public static partial class Modify
+    {
+        /***************************************************/
+        /****               Public Methods              ****/
+        /***************************************************/
+
+        [Description("Sets the Outline Element1Ds of a PadFoundation, i.e. the ExternalBoundary. Method required for all IElement2Ds.\n" +
+                     "The provided edges all need to be ICurves and should form a closed loop. No checking for planarity is made by the method.\n" +
+                     "The Method will return a new PadFoundation with the provided edges as the TopSurface.")]
+        [Input("padFoundation", "The PadFoundation to update the ExternalEdge of.")]
+        [Input("edges", "A list of IElement1Ds which all should be of a type of ICurve.")]
+        [Output("padFoundation", "A new PadFoundation with TopSurface matching the provided edges.")]
+        public static PadFoundation SetOutlineElements1D(this PadFoundation padFoundation, IEnumerable<IElement1D> edges)
+        {
+            if (padFoundation.IsNull())
+                return padFoundation;
+
+            List<Edge> externalEdges = edges.Cast<Edge>().ToList();
+
+            return Create.PadFoundation(externalEdges, padFoundation.Property, padFoundation.Orientation);
+        }
+
+        /***************************************************/
+
+    }
+}
+
+
+

Structure_Engine/Modify/Transform.cs

@@ -249,6 +249,33 @@ public static FEMesh Transform(this FEMesh mesh, TransformMatrix transform, doub
         }
 
         /***************************************************/
+
+        /***************************************************/
+
+        [Description("Transforms the PadFoundation's edges, openings and basis by the transform matrix. Only rigid body transformations are supported.")]
+        [Input("padFoundation", "PadFoundation to transform.")]
+        [Input("transform", "Transform matrix.")]
+        [Input("tolerance", "Tolerance used in the check whether the input matrix is equivalent to the rigid body transformation.")]
+        [Output("transformed", "Modified PadFoundation with unchanged properties, but transformed edges and basis.")]
+        public static PadFoundation Transform(this PadFoundation padFoundation, TransformMatrix transform, double tolerance = Tolerance.Distance)
+        {
+            if (padFoundation == null)
+            {
+                Base.Compute.RecordError("Could not transform the PadFoundation because it was null.");
+                return null;
+            }
+
+            if (!transform.IsRigidTransformation(tolerance))
+            {
+                Base.Compute.RecordError("Transformation failed: only rigid body transformations are currently supported.");
+                return null;
+            }
+
+            PadFoundation result = padFoundation.ShallowClone();
+            result.Orientation = result.Orientation.Transform(transform);
+
+            return result;
+        }
     }
 }