Geometry_Engine: Split bugs fixed and OutlinesFromLines method added

Architecture_Engine/Compute/CeilingTiles.cs

@@ -20,33 +20,26 @@
  * 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.Text;
-using System.Threading.Tasks;
-
-using BH.oM.Architecture.Elements;
-
-using BH.oM.Geometry;
 using BH.Engine.Geometry;
-using System.Runtime.InteropServices;
-
+using BH.oM.Architecture.Elements;
 using BH.oM.Base.Attributes;
+using BH.oM.Geometry;
+using System.Collections.Generic;
 using System.ComponentModel;
+using System.Linq;
 
 namespace BH.Engine.Architecture
 {
     public static partial class Compute
     {
+        [PreviousVersion("7.1", "BH.Engine.Architecture.Compute.CeilingTiles(BH.oM.Architecture.Elements.Ceiling, System.Collections.Generic.List<BH.oM.Geometry.Line>, System.Double, System.Double, System.Int32)")]
         [Description("Generate a collection of Ceiling Tile objects that can sit within the given ceiling. Uses the BH.Engine.Geometry.Compute.Split(Polyline, List<Line>) method for its core.")]
         [Input("ceiling", "Ceiling object which provides the outer perimeter of the ceiling tiles")]
         [Input("ceilingTileLines", "The lines across the ceiling which will be used to cut the ceiling into individual tiles.")]
         [Input("angleTolerance", "Tolerance used for angle calculations. Default set to BH.oM.Geometry.Tolerance.Angle.")]
         [Input("distanceTolerance", "Tolerance used for distance calculations. Default set to BH.oM.Geometry.Tolerance.Distance")]
-        [Input("decimalPlaces", "All coordinates of the geometry will be rounded to the number of decimal places specified. Default 6.")]
         [Output("ceilingTiles", "Closed Ceiling Tile regions contained within the Ceiling.")]
-        public static List<CeilingTile> CeilingTiles(Ceiling ceiling, List<Line> ceilingTileLines, double angleTolerance = BH.oM.Geometry.Tolerance.Angle, double distanceTolerance = BH.oM.Geometry.Tolerance.Distance, int decimalPlaces = 6)
+        public static List<CeilingTile> CeilingTiles(Ceiling ceiling, List<Line> ceilingTileLines, double angleTolerance = BH.oM.Geometry.Tolerance.Angle, double distanceTolerance = BH.oM.Geometry.Tolerance.Distance)
         {
             if(ceiling == null)
             {
@@ -60,7 +53,7 @@
 
             Polyline outerPerimeter = ceiling.Surface.IExternalEdges().Select(x => x.ICollapseToPolyline(angleTolerance)).ToList().Join()[0];
 
-            List<Polyline> regions = BH.Engine.Geometry.Compute.Split(outerPerimeter, ceilingTileLines, distanceTolerance, decimalPlaces);
+            List<Polyline> regions = BH.Engine.Geometry.Compute.Split(outerPerimeter, ceilingTileLines, distanceTolerance);
 
             List<CeilingTile> tiles = new List<CeilingTile>();
 

BHoM_Engine/Query/IsNullOrEmpty.cs → BHoM_Engine/Query/IsNull.cs

@@ -37,37 +37,60 @@ public static partial class Query
         /**** Public Methods                            ****/
         /***************************************************/
 
-        [Description("Checks if a List is null and outputs relevant error message.")]
-        [Input("list", "The List to test for null.")]
+        [Description("Checks if a collection is null or empty and outputs relevant error message.")]
+        [Input("collection", "The collection to test for null value or emptiness.")]
+        [Input("msg", "Optional message to be returned in addition to the generated error message.")]
         [Input("methodName", "The name of the method to reference in the error message.")]
+        [Output("isNull", "True if the collection is null or empty.")]
+        public static bool IsNullOrEmpty<T>(this IEnumerable<T> collection, string msg = "", [CallerMemberName] string methodName = "")
+        {
+            return collection.NullCheckCollection(true, msg, methodName);
+        }
+
+        /***************************************************/
+
+        [Description("Checks if a collection is null and outputs relevant error message.")]
+        [Input("collection", "The collection to test for null value.")]
         [Input("msg", "Optional message to be returned in addition to the generated error message.")]
-        [Output("isNull", "True if the List or its elements are null.")]
-        public static bool IsNullOrEmpty<T>(this IEnumerable<T> list, string msg = "", [CallerMemberName] string methodName = "")
+        [Input("methodName", "The name of the method to reference in the error message.")]
+        [Output("isNull", "True if the collection is null.")]
+        public static bool IsNull<T>(this IEnumerable<T> collection, string msg = "", [CallerMemberName] string methodName = "")
         {
-            if (list == null)
+            return collection.NullCheckCollection(false, msg, methodName);
+        }
+
+
+        /***************************************************/
+        /**** Private Methods                           ****/
+        /***************************************************/
+
+        private static bool NullCheckCollection<T>(this IEnumerable<T> collection, bool checkForEmpty, string msg, string methodName)
+        {
+            if (collection == null)
             {
                 if (string.IsNullOrEmpty(methodName))
                 {
                     methodName = "Method";
                 }
-                Base.Compute.RecordError($"Cannot evaluate {methodName} because the List failed a null check. {msg}");
+                Base.Compute.RecordError($"Cannot evaluate {methodName} because the input collection failed a null check. {msg}");
 
                 return true;
             }
-            else if (!list.Any())
+            else if (checkForEmpty && !collection.Any())
             {
                 if (string.IsNullOrEmpty(methodName))
                 {
                     methodName = "Method";
                 }
-                Base.Compute.RecordError($"Cannot evaluate {methodName} because the List is empty. {msg}");
+                Base.Compute.RecordError($"Cannot evaluate {methodName} because the input collection is empty. {msg}");
 
                 return true;
             }
 
             return false;
         }
 
+        /***************************************************/
     }
 }
 

Geometry_Engine/Compute/BooleanUnion.cs

@@ -42,7 +42,7 @@
         [Input("refLine", "Second line to union.")]
         [Input("tolerance", "Tolerance used for checking colinearity and proximity of the lines.", typeof(Length))]
         [Output("union", "Boolean union of the lines.")]
         public static List<Line> BooleanUnion(this Line line, Line refLine, double tolerance = Tolerance.Distance, bool keepIntermediatePoints = false)
         {
             double sqTol = tolerance * tolerance;
             List<Line> result = new Line[] { line, refLine }.Where(x => x != null && x.SquareLength() > sqTol).ToList();
@@ -59,7 +59,7 @@
         [Input("lines", "Lines to union.")]
         [Input("tolerance", "Tolerance used for checking colinearity and proximity of the lines.", typeof(Length))]
         [Output("union", "Boolean union of the lines.")]
         public static List<Line> BooleanUnion(this List<Line> lines, double tolerance = Tolerance.Distance, bool keepIntermediatePoints = false)
         {
             double sqTol = tolerance * tolerance;
             return lines.Where(x => x != null && x.SquareLength() > sqTol)
@@ -488,20 +488,20 @@
             extraSteps.Add(0, new List<double>());
             foreach (double step in steps)
             {
+                while (step - mergedRanges[i].Item2 > tolerance)
+                {
+                    i++;
+                    extraSteps.Add(i, new List<double>());
+                }
+
                 if (step - mergedRanges[i].Item1 > tolerance)
                 {
+
                     if (mergedRanges[i].Item2 - step > tolerance && extraSteps[i].All(x => Math.Abs(x - step) > tolerance))
                         extraSteps[i].Add(step);
-                    else
-                    {
-                        i++;
-                        extraSteps.Add(i, new List<double>());
-                    }
                 }
             }
 
-            extraSteps.Remove(i);
-
             List<(double, double)> mergedMerged = new List<(double, double)>();
             foreach (int j in extraSteps.Keys.OrderBy(x => x))
             {