See 'CHANGELOG.md' for commit details.

Author: IrishFix

CHANGELOG.md

@@ -9,6 +9,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## 1.1.0 - 2023-07-05
+
+### Added
+
+- An untested version of constrained triangulation; along with all Triangle2D / 3D data that was required to be edited to ensure a working format.#
+
+### Changed
+
+- Voxelization now voxelizes spaces using grids instead of lists to ensure connectivity stays consistent.
+
+### Fixed
+
+- Networking/Genetics has now been re-added in an un-tested state. It (should) allow neural networks to be correctly trained using genetic algorithms.
+- Predicted / Expected values were swapped in a MSE calculation during a fit stage in the  neural network training that could case some backwards learning gradients. I was unable to find a case in which it did infact cause said problem, but it is better to ensure it works as expected by using the right method.
+
 ## 1.0.2 - 2023-05-06
 
 ### Changed

Runtime/Geometrics/Triangle2D.cs

@@ -28,7 +28,17 @@ public Triangle2D(Edge2D a, Vector2 b) {
             Edges = new[] {new Edge2D(Vertices[0],Vertices[1]),new Edge2D(Vertices[1],Vertices[2]),new Edge2D(Vertices[2],Vertices[0])};
             UpdateCircumcircle();
         }
-        
+
+        public Triangle2D(Edge2D Edge) {
+            Vertices = new[] { Edge.Vertices[0], Edge.Vertices[1] };
+            Edges = new[] { Edge };
+            
+            double Radius = Edge.GetLength();
+            
+            RadiusSquared = Radius * Radius;
+            Circumcenter = Edge.GetMidpoint();
+        }
+
         public Triangle2D(Triangle3D Triangle, bool FlattenToXZ=true) {
             Vector2 a, b, c; // Projects 3D Triangle to 2D Plane
             if (FlattenToXZ) { // To XZ Plane (If using XZ Plane, Y of 2d vectors will be Z of 3d vectors)

Runtime/Geometrics/Triangulation.cs

@@ -7,7 +7,7 @@
 namespace UniversalNumerics.Geometrics {
     public static class Triangulation {
 
-        public static IEnumerable<Triangle2D> BowyerWatsonTriangulation(IEnumerable<Vector2> PointCloud) {
+        public static IEnumerable<Triangle2D> Triangulate(IEnumerable<Vector2> PointCloud) {
             List<Triangle2D> Triangulation = new List<Triangle2D>();
 
             Triangle2D SuperTriangle = new Triangle2D(
@@ -77,17 +77,7 @@ private static bool PointInList(Vector2 Point, List<Vector2> Points, float Toler
             return Points.Any(OtherPoint => Vector2.DistanceSquared(OtherPoint, Point) < SqrTol);
         }
 
-        [Pure] private static IEnumerable<Vector2> CleanPoints(IEnumerable<Vector2> UncleanPoints) {
-            List<Vector2> CleanedPoints = new List<Vector2>();
-            foreach (Vector2 Point in UncleanPoints) {
-                if (!PointInList(Point, CleanedPoints)) {
-                    CleanedPoints.Add(Point);
-                }
-            }
-            return CleanedPoints;
-        }
-
-        [Pure] public static IEnumerable<Triangle2D> BowyerWatsonTriangulation(IEnumerable<Edge2D> PSG) {
+        [Pure] public static IEnumerable<Triangle2D> Triangulate(IEnumerable<Edge2D> PSG) {
             List<Vector2> PointCloud = new List<Vector2>();
             foreach (Edge2D Edge in PSG) {
                 if (!PointInList(Edge.A, PointCloud)) {
@@ -97,7 +87,7 @@ [Pure] public static IEnumerable<Triangle2D> BowyerWatsonTriangulation(IEnumerab
                     PointCloud.Add(Edge.B);
                 }
             }
-            return BowyerWatsonTriangulation(PointCloud);
+            return Triangulate(PointCloud);
         }
 
         [Pure] public static IEnumerable<Edge2D> VoronoiFromTriangulation(IEnumerable<Triangle2D> Triangulation) {
@@ -123,110 +113,95 @@ [Pure] private static bool IsPoorTriangle(Triangle2D Triangle, float Threshold)
             return (Angle1 < Threshold || Angle2 < Threshold || Angle3 < Threshold);
         }
 
-        [Pure] private static IEnumerable<Edge2D> GetEncroachedSegments(IEnumerable<Edge2D> Segments, IEnumerable<Vector2> PointCloud) {
-            List<Edge2D> EncroachedEdges = new List<Edge2D>();
-            foreach (Edge2D Segment in Segments) {
-                bool Encroached = false;
-                foreach (Vector2 Point in PointCloud) {
-                    Encroached = Segment.EncroachedByPoint(Point);
-                    if (Encroached) {
-                        break;
+        [Pure] private static Edge2D GetIntersectingEdge(List<Triangle2D> Triangulation) {
+            foreach (Triangle2D Tri in Triangulation) {
+                foreach (Triangle2D OtherTri in Triangulation) {
+                    if (Tri.Equals(OtherTri)) continue;
+                    foreach (Edge2D Edge in Tri.Edges) {
+                        foreach (Edge2D OtherEdge in OtherTri.Edges) {
+                            if (Intersection.AreSegmentsIntersecting(Edge.A, Edge.B, OtherEdge.A, OtherEdge.B)) {
+                                return Edge;
+                            }
+                        }
                     }
                 }
-                if (Encroached) {
-                    EncroachedEdges.Add(Segment);
-                }
             }
-            return EncroachedEdges;
+            return null;
         }
-
-        [Pure] public static IEnumerable<Triangle2D> ConstrainedBowyerWatsonTriangulation(IEnumerable<Vector2> PointCloud, IEnumerable<Edge2D> ConstraintEdges, float Threshold = 26) {
-            List<Vector2> PointCloudList = CleanPoints(PointCloud).ToList();
-            List<Edge2D> ConstraintEdgeList = ConstraintEdges.ToList();
-            List<Triangle2D> Triangulation = BowyerWatsonTriangulation(PointCloudList).ToList();
-            List<Edge2D> EncroachedSegments = new List<Edge2D>();
-            List<Triangle2D> PoorTriangles = new List<Triangle2D>();
-
-            foreach (Edge2D ConstraintEdge in ConstraintEdgeList) {
-                
-                if (!PointInList(ConstraintEdge.A, PointCloudList)) {
-                    PointCloudList.Add(ConstraintEdge.A);
-                } 
-                if (!PointInList(ConstraintEdge.B, PointCloudList)) {
-                    PointCloudList.Add(ConstraintEdge.B);
-                }
-
-                foreach (Vector2 Point in PointCloudList) {
-                    if (ConstraintEdge.EncroachedByPoint(Point)) {
-                        EncroachedSegments.Add(ConstraintEdge);
-                        break;
+        
+        [Pure] private static bool HasIntersectingEdges(List<Edge2D> Edges) {
+            foreach (Edge2D Edge in Edges) {
+                foreach (Edge2D OtherEdge in Edges) {
+                    if (Edge.Equals(OtherEdge)) continue;
+                    if (Intersection.AreSegmentsIntersecting(Edge.A, Edge.B, OtherEdge.A, OtherEdge.B)) {
+                        return true;
                     }
                 }
             }
+            return false;
+        }
+
+        [Pure] private static Triangle2D[] GetEdgeSharedTriangles(IEnumerable<Triangle2D> Triangles, Edge2D Edge) {
+            IEnumerable<Triangle2D> OtherTriangles = Triangles.ToList();
 
-            foreach (Triangle2D Triangle in Triangulation) {
-                if (IsPoorTriangle(Triangle, Threshold)) {
-                    PoorTriangles.Add(Triangle);
+            foreach (Triangle2D Triangle in OtherTriangles) {
+                foreach (Triangle2D OtherTriangle in OtherTriangles) {
+                    if (Triangle.Equals(OtherTriangle)) continue;
+                    if (Triangle.SharedEdgeWith(OtherTriangle).Equals(Edge)) {
+                        return new[] { Triangle, OtherTriangle };
+                    }
                 }
             }
 
-            while (EncroachedSegments.Count > 0 || PoorTriangles.Count > 0) {
-                List<Edge2D> EdgesToRemove = new List<Edge2D>();
-                List<Triangle2D> TrianglesToRemove = new List<Triangle2D>();
-                
-                foreach (Edge2D EncroachedSegment in EncroachedSegments) {
-                    Vector2 Midpoint = EncroachedSegment.GetMidpoint();
-                    PointCloudList.Add(Midpoint);
-                    EdgesToRemove.Add(EncroachedSegment);
-                    ConstraintEdgeList.Remove(EncroachedSegment);
-                    ConstraintEdgeList.Add(new Edge2D(Midpoint,  EncroachedSegment.A));
-                    ConstraintEdgeList.Add(new Edge2D(Midpoint,  EncroachedSegment.B));
-                }
-
-                foreach (Edge2D EdgeToRemove in EdgesToRemove) {
-                    EncroachedSegments.Remove(EdgeToRemove);
-                }
-
-                foreach (Triangle2D Triangle in PoorTriangles) {
-                    Vector2 Midpoint = Triangle.Circumcenter;
-                    List<Edge2D> SegmentsEncroachedByMidpoint = new List<Edge2D>();
-                    foreach (Edge2D Segment in ConstraintEdgeList) {
-                        if (Segment.EncroachedByPoint(Midpoint)) {
-                            SegmentsEncroachedByMidpoint.Add(Segment);
-                        }
-                    }
+            return null;
+        }
 
-                    if (SegmentsEncroachedByMidpoint.Count > 0) {
-                        EncroachedSegments.AddRange(SegmentsEncroachedByMidpoint);
-                    }
-                    else {
-                        PointCloudList.Add(Midpoint);
-                    }
-                    TrianglesToRemove.Add(Triangle);
-                }
-                
-                foreach (Triangle2D TriangleToRemove in TrianglesToRemove) {
-                    PoorTriangles.Remove(TriangleToRemove);
-                }
+        [Pure] private static List<Triangle2D> ToTriangles(List<Edge2D> Edges) {
+            List<Triangle2D> outputTriangles = new List<Triangle2D>();
+            for (int i = 0; i < Edges.Count; i += 3) {
+                outputTriangles.Add(new Triangle2D(Edges[i].A, Edges[i+1].A, Edges[i+2].A));
+            }
+            return outputTriangles;
+        }
 
-                Triangulation = BowyerWatsonTriangulation(PointCloudList).ToList();
-                
-                foreach (Edge2D ConstraintEdge in ConstraintEdgeList) {
-                    foreach (Vector2 Point in PointCloudList) {
-                        if (ConstraintEdge.EncroachedByPoint(Point)) {
-                            EncroachedSegments.Add(ConstraintEdge);
-                            break;
-                        }
-                    }
-                }
-                
-                foreach (Triangle2D Triangle in Triangulation) {
-                    if (IsPoorTriangle(Triangle, Threshold)) {
-                        PoorTriangles.Add(Triangle);
-                    }
-                }
+        [Pure] public static IEnumerable<Triangle2D> ConstrainedTriangulation(IEnumerable<Vector2> PointCloud, IEnumerable<Edge2D> ConstraintEdges, float Threshold = 26) {
+            List<Triangle2D> Triangulation = Triangulate(PointCloud).ToList();
+            foreach (Edge2D ConstraintEdge in ConstraintEdges) {
+                Triangulation.Add(new Triangle2D(ConstraintEdge));
             }
 
+            Edge2D NextIntersectingEdge = GetIntersectingEdge(Triangulation);
+
+            while (NextIntersectingEdge != null) {
+                foreach (Triangle2D Triangle in GetEdgeSharedTriangles(Triangulation, NextIntersectingEdge)) {
+                    Vector2 v1 = Triangle.A;
+                    Vector2 v2 = Triangle.B;
+                    Vector2 v3 = Triangle.C;
+                    
+                    Triangulation.Remove(Triangle);
+                    
+                    Triangle2D t1 = new(NextIntersectingEdge.A, v1, v2);
+                    Triangle2D t2 = new(NextIntersectingEdge.B, v1, v2);
+                    Triangle2D t3 = new(NextIntersectingEdge.A, v2, v3);
+                    Triangle2D t4 = new(NextIntersectingEdge.B, v2, v3);
+                    Triangle2D t5 = new(NextIntersectingEdge.A, v3, v1);
+                    Triangle2D t6 = new(NextIntersectingEdge.B, v3, v1);
+                    
+                    t1.Vertices[2] = t2.Vertices[2] = v2;
+                    t3.Vertices[2] = t4.Vertices[2] = v3;
+                    t5.Vertices[2] = t6.Vertices[2] = v1;
+                    
+                    Triangulation.Add(t1);
+                    Triangulation.Add(t2);
+                    Triangulation.Add(t3);
+                    Triangulation.Add(t4);
+                    Triangulation.Add(t5);
+                    Triangulation.Add(t6);
+                }
+
+                NextIntersectingEdge = GetIntersectingEdge(Triangulation);
+            }
+
             return Triangulation;
         }
 

Runtime/Geometrics/Voxel.cs

@@ -0,0 +1,14 @@
+using System.Numerics;
+
+// ReSharper disable once CheckNamespace
+namespace UniversalNumerics.Geometrics {
+    public struct Voxel {
+        public Vector3 position;
+        public float size;
+
+        public Voxel(Vector3 position, float size) {
+            this.position = position;
+            this.size = size;
+        }
+    }
+}

Runtime/Geometrics/Voxel.cs.meta

@@ -1,28 +1,42 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Numerics;
 
 // ReSharper disable once CheckNamespace
 namespace UniversalNumerics.Geometrics {
     public static class Voxelization {
+        public static int EstimateVoxelCount(Vector3 areaSize, float voxelSize) {
+            int cellsX = (int)System.Math.Ceiling(areaSize.X / voxelSize);
+            int cellsY = (int)System.Math.Ceiling(areaSize.Y / voxelSize);
+            int cellsZ = (int)System.Math.Ceiling(areaSize.Z / voxelSize);
+            return cellsX * cellsY * cellsZ;
+        }
+        
+        public static Vector3 CalculateVoxelGridSize(Vector3 areaSize, float voxelSize) {
+            Vector3 voxelGridSize = Vector3.Zero;
+
+            voxelGridSize.X = (int)Math.Ceiling(areaSize.X / voxelSize);
+            voxelGridSize.Y = (int)Math.Ceiling(areaSize.Y / voxelSize);
+            voxelGridSize.Z = (int)Math.Ceiling(areaSize.Z / voxelSize);
 
-        public static int GetSubvoxelEstimate(Vector3 AreaSize, Vector3 VoxelSize) {
-            int CellsX = (int)System.Math.Ceiling(AreaSize.X / VoxelSize.X), CellsY = (int)System.Math.Ceiling(AreaSize.Y / VoxelSize.Y), CellsZ = (int)System.Math.Ceiling(AreaSize.Z / VoxelSize.Z);
-            return CellsX * CellsZ * CellsY;
+            return voxelGridSize;
         }
 
-        public static IEnumerable<Vector3> VoxelizeArea(Vector3 Center, Vector3 AreaSize, Vector3 VoxelSize) {
-            Vector3 StartPosition = Center + AreaSize/2 - VoxelSize/2;
-            int CellsX = (int)System.Math.Ceiling(AreaSize.X / VoxelSize.X), CellsY = (int)System.Math.Ceiling(AreaSize.Y / VoxelSize.Y), CellsZ = (int)System.Math.Ceiling(AreaSize.Z / VoxelSize.Z);
-            List<Vector3> Voxels = new(CellsX*CellsY*CellsZ);
-            for (int i = 0; i < CellsX; i++) {
-                for (int j = 0; j < CellsZ; j++) {
-                    for (int k = 0; k < CellsY; k++) {
-                        Vector3 VoxelPosition = StartPosition - new Vector3(VoxelSize.X * i, VoxelSize.Y * k, VoxelSize.Z * j);
-                        Voxels.Add(VoxelPosition);
+        public static Voxel[,,] VoxelizeArea(Vector3 areaCenter, Vector3 areaSize, float voxelSize) {
+            Vector3 voxelGridSize = CalculateVoxelGridSize(areaSize, voxelSize);
+            
+            Voxel[,,] voxelGrid = new Voxel[(int)voxelGridSize.X, (int)voxelGridSize.Y, (int)voxelGridSize.Z];
+
+            for (int x = 0; x < (int)voxelGridSize.X; x++) {
+                for (int y = 0; y < (int)voxelGridSize.Y; y++) {
+                    for (int z = 0; z < (int)voxelGridSize.Z; z++) {
+                        Vector3 voxelPosition = areaCenter + new Vector3(x * voxelSize, y * voxelSize, z * voxelSize);
+                        voxelGrid[x, y, z] = new Voxel(voxelPosition, voxelSize);
                     }
                 }
             }
-            return Voxels;
+
+            return voxelGrid;
         }
 
     }