0.5.5

Author: Geri-Borbas

CHANGELOG.md

@@ -1,4 +1,15 @@
-# eppz! <sub>Geometry</sub>
+# eppz! `Geometry`
+
+* 0.5.5
+
+	+ Only calculated winding direction
+		+ Removed option to define polygon winding
+		+ Removed distinct `_signedArea`
+			+ `area` is always (!) signed
+		+ Polygon calculations grouped together 
+		+ Renamed to simply `winding`
+	+ `Geometry`
+		+ `CentroidOfPolygons` use `area` directly (being always signed)
 
 * 0.5.1
 

Components/PolygonSource.cs

@@ -19,7 +19,6 @@ public class PolygonSource : MonoBehaviour
 
 
 		public Transform[] pointTransforms;
-		public Polygon.WindingDirection windingDirection = Polygon.WindingDirection.Unknown;
 		[Range (-2,2)] public float offset = 0.0f;
 		public bool updateModel = false;
 
@@ -39,7 +38,6 @@ void Update()
 			{
 				// Update polygon model with transforms, also update calculations.
 				polygon.UpdatePointPositionsWithSource(this);
-				windingDirection = polygon.windingDirection;
 				if (offset != 0.0f) polygon = polygon.OffsetPolygon(offset);
 			}
 		}

Geometry.cs

@@ -174,28 +174,21 @@ public static bool IsPolygonContainsPoint(Polygon polygon, Vector2 point)
 			return isOdd;
 		}
 
-		public static Vector2 CentroidOfPolygons(Polygon[] polygons, Polygon.WindingDirection windingDirection = Polygon.WindingDirection.Unknown)
+		public static Vector2 CentroidOfPolygons(Polygon[] polygons)
 		{
-			if (windingDirection == Polygon.WindingDirection.Unknown)
-			{ windingDirection = polygons[0].windingDirection; }
-
 			// From https://en.wikipedia.org/wiki/Centroid#By_geometric_decomposition
 			float ΣxA = 0.0f;
 			float ΣyA = 0.0f;
 			float ΣA = 0.0f;
 			foreach (Polygon eachPolygon in polygons)
 			{
-				// Add or subtract area.
-				float sign = (eachPolygon.windingDirection == windingDirection) ? 1.0f : -1.0f;
-				float eachSignedArea = eachPolygon.area * sign;
-
 				// Get centroid.
 				Vector2 eachCentroid = eachPolygon.centroid;
 
 				// Sum weighted.
-				ΣxA += eachCentroid.x * eachSignedArea;
-				ΣyA += eachCentroid.y * eachSignedArea;
-				ΣA += eachSignedArea;	
+				ΣxA += eachCentroid.x * eachPolygon.area;
+				ΣyA += eachCentroid.y * eachPolygon.area;
+				ΣA += eachPolygon.area;	
 			}
 
 			// "Remove" area.

Lines/PolygonLineRenderer.cs

@@ -24,12 +24,12 @@ public class PolygonLineRenderer : GeometryLineRenderer
 
 		public Color lineColor;
 		public Color boundsColor;
-		public GameObject windingDirectionObject;
+		public GameObject windingObject;
 		public TextMesh areaTextMesh;
 		public bool normals = false;
 
 		private float _previousArea;
-		private Polygon.WindingDirection _previousWindingDirection;
+		private Polygon.Winding _previousWindingDirection;
 
 		public Polygon polygon;
 
@@ -47,12 +47,12 @@ void Update()
 			if (polygon == null) return; // Only having polygon
 
 			// Layout winding direction object if any.
-			bool hasWindingDirectionObject = (windingDirectionObject != null);
-			bool windingChanged = (polygon.windingDirection != _previousWindingDirection);
+			bool hasWindingDirectionObject = (windingObject != null);
+			bool windingChanged = (polygon.winding != _previousWindingDirection);
 			if (hasWindingDirectionObject && windingChanged)
 			{
-				windingDirectionObject.transform.localScale = (polygon.isCW) ? Vector3.one : new Vector3 (1.0f, -1.0f, 1.0f);
-				windingDirectionObject.transform.rotation = (polygon.isCW) ? Quaternion.identity : Quaternion.Euler( new Vector3 (0.0f, 0.0f, 90.0f) );
+				windingObject.transform.localScale = (polygon.isCW) ? Vector3.one : new Vector3 (1.0f, -1.0f, 1.0f);
+				windingObject.transform.rotation = (polygon.isCW) ? Quaternion.identity : Quaternion.Euler( new Vector3 (0.0f, 0.0f, 90.0f) );
 			}
 
 			// Layout area text mesh if any.
@@ -64,7 +64,7 @@ void Update()
 			}
 
 			// Track.
-			_previousWindingDirection = polygon.windingDirection;
+			_previousWindingDirection = polygon.winding;
 			_previousArea = polygon.area;
 		}
 

Model/Polygon.cs

@@ -9,7 +9,6 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-
 using System.Linq;
 using ClipperLib;
 
@@ -35,12 +34,11 @@ public class Polygon
 		public string name;
 
 		// Windings.
-		[HideInInspector] public enum WindingDirection { Unknown, CCW, CW };
-		private WindingDirection _windingDirection = WindingDirection.Unknown;
-		public WindingDirection windingDirection { get { return _windingDirection; } }
-		public bool isCW { get { return (_windingDirection == WindingDirection.CW); } }
-		public bool isCCW { get { return (_windingDirection == WindingDirection.CCW); } }
-
+		public bool isCW { get { return (Mathf.Sign(_area) < 0.0f); } }
+		public bool isCCW { get { return (Mathf.Sign(_area) > 0.0f); } }		
+		public enum Winding { CCW, CW };		
+		public Winding winding { get { return (isCCW) ? Winding.CCW : Winding.CW; } }
+		
 		/// <remarks>
 		/// For internal use.
 		/// Edge, Vertex class can read from this directly
@@ -57,12 +55,9 @@ public class Polygon
 		private Rect _bounds = new Rect();
 		public Rect bounds { get { return _bounds; } }
 
-		private float _area;
+		private float _area = 0.0f;
 		public float area { get { return _area; } }
 
-		private float _signedArea;
-		public float signedArea { get { return _signedArea; } }
-
 		// Yet for single polygons only (see centroid of compound polygons).
 		private Vector2 _centroid;
 		public Vector2 centroid { get { return _centroid; } }
@@ -75,7 +70,7 @@ public static Polygon PolygonWithPointList(List<Vector2> pointList)
 
 		public static Polygon PolygonWithSource(PolygonSource polygonSource)
 		{
-			Polygon rootPolygon = Polygon.PolygonWithPointTransforms(polygonSource.pointTransforms, polygonSource.windingDirection);
+			Polygon rootPolygon = Polygon.PolygonWithPointTransforms(polygonSource.pointTransforms);
 
 			// Collect sub-olygons if any.
 			foreach (Transform eachChildTransform in polygonSource.gameObject.transform)
@@ -112,10 +107,7 @@ public static Polygon PolygonWithPolygon(Polygon polygon)
 			return rootPolygon;
 		}
 
-		public static Polygon PolygonWithPointTransforms(Transform[] pointTransforms)
-		{ return PolygonWithPointTransforms(pointTransforms, WindingDirection.Unknown); }
-
-		public static Polygon PolygonWithPointTransforms(Transform[] pointTransforms, WindingDirection windingDirection) // Uses Transform.localPosition.xy()
+		public static Polygon PolygonWithPointTransforms(Transform[] pointTransforms) // Uses Transform.localPosition.xy()
 		{
 			// Create points array.
 			Vector2[] points = new Vector2[pointTransforms.Length];
@@ -125,19 +117,13 @@ public static Polygon PolygonWithPointTransforms(Transform[] pointTransforms, Wi
 				points[index] = eachPointTransform.localPosition.xy();
 			}
 
-			return Polygon.PolygonWithPoints(points, windingDirection);
+			return Polygon.PolygonWithPoints(points);
 		}
 
 		public static Polygon PolygonWithPoints(Vector2[] points)
-		{ return PolygonWithPoints(points, WindingDirection.Unknown); }
-
-		public static Polygon PolygonWithPoints(Vector2[] points, WindingDirection windingDirection)
-		{ return PolygonWithPoints(points, 0.0f, windingDirection); }
+		{ return PolygonWithPoints(points, 0.0f); }
 
 		public static Polygon PolygonWithPoints(Vector2[] points, float angle)
-		{ return PolygonWithPoints(points, angle, WindingDirection.Unknown); }
-
-		public static Polygon PolygonWithPoints(Vector2[] points, float angle, WindingDirection windingDirection)
 		{
 			Polygon polygon = new Polygon(points.Length);
 
@@ -151,10 +137,7 @@ public static Polygon PolygonWithPoints(Vector2[] points, float angle, WindingDi
 			}
 
 			// Polygon calculations.
-			polygon.CalculateBounds();
-			polygon.CalculateArea();
-			polygon.CalculateWindingDirectionIfNeeded();
-			polygon.CalculateCentroid();
+			polygon.Calculate();
 
 			// Create members.
 			polygon.CreateVerticesFromPoints();
@@ -189,21 +172,15 @@ public void UpdatePointPositionsWithTransforms(Transform[] pointTransforms) // A
 			}
 
 			// Polygon calculations.
-			CalculateBounds();
-			CalculateArea();
-			CalculateCentroid();
-			_windingDirection = WindingDirection.Unknown;
-			CalculateWindingDirectionIfNeeded();
+			Calculate();
 		}
 
 		public void AddPolygon(Polygon polygon)
 		{
 			polygons.Add(polygon);
 
 			// Polygon calculations.
-			CalculateBounds();
-			CalculateArea();
-			CalculateCentroid();
+			Calculate();
 		}
 
 	#endregion
@@ -330,7 +307,14 @@ public void EnumeratePolygons(Action<Polygon> action)
 
 	#region Polygon calculations
 
-		private void CalculateBounds()
+		void Calculate()
+		{
+			_CalculateBounds();
+			_CalculateArea();
+			_CalculateCentroid();
+		}
+
+		void _CalculateBounds()
 		{
 			float left = float.MaxValue; // Out in the right
 			float right = float.MinValue; // Out in the left
@@ -354,27 +338,15 @@ private void CalculateBounds()
 			_bounds.yMax = top;
 		}
 
-		private void CalculateArea()
+		private void _CalculateArea()
 		{
 
 			// From https://en.wikipedia.org/wiki/Shoelace_formula
 			Vector2[] points_ = new Vector2[_points.Length + 1];
-			
-			// Create point list for calculations.
-			if (windingDirection == WindingDirection.CW)
-			{
-				Vector2[] reversed = new Vector2[_points.Length];
-				System.Array.Copy(_points, reversed, _points.Length);
-				System.Array.Copy(reversed, points_, _points.Length);
-			}
-			
-			if (windingDirection == WindingDirection.CCW ||
-				windingDirection == WindingDirection.Unknown)
-			{ System.Array.Copy(_points, points_, _points.Length); }
-			
+			System.Array.Copy(_points, points_, _points.Length);
 			points_[_points.Length] = _points[0];
 
-			// Calculations.
+			// Calculate area.
 			float firstProducts = 0.0f;
 			float secondProducts = 0.0f;
 			for (int index = 0; index < points_.Length - 1; index++)
@@ -385,27 +357,17 @@ private void CalculateArea()
 				firstProducts += eachPoint.x * eachNextPoint.y;
 				secondProducts += eachPoint.y * eachNextPoint.x;
 			}
-			float area_ = (firstProducts - secondProducts) / 2.0f;
-			
-			// Set signed area.
-			_signedArea = area_;
-
-			// Set area.
-			_area = Mathf.Abs(area_);
+			float _area = (firstProducts - secondProducts) / 2.0f;
 
 			// Add / Subtract sub-polygon areas.
-			float subPolygonAreas = 0.0f;
 			foreach (Polygon eachPolygon in polygons)
 			{
 				// Outer or inner polygon (supposing there is no self-intersection).
-				float subPolygonArea = eachPolygon.CalculatedArea();
-				subPolygonAreas += (eachPolygon.windingDirection == windingDirection) ? subPolygonArea : -subPolygonArea;
+				_area += eachPolygon.area;
 			}
-
-			_area = _area + subPolygonAreas;
 		}
 
-		private void CalculateCentroid()
+		private void _CalculateCentroid()
 		{
 			// Enumerate points.
 			float Σx = 0.0f;
@@ -423,26 +385,6 @@ private void CalculateCentroid()
 			// Assign.
 			_centroid = new Vector2(x, y);
 		}
-		
-		private float CalculatedArea()
-		{
-			CalculateArea();
-			return _area;
-		}
-
-		private Vector2 CalculatedCentroid()
-		{
-			CalculateCentroid();
-			return _centroid;
-		}
-
-		private void CalculateWindingDirectionIfNeeded()
-		{
-			if (_windingDirection == WindingDirection.Unknown) // Only if unknown
-			{
-				_windingDirection = (Mathf.Sign(_signedArea) > 0.0f) ? WindingDirection.CCW : WindingDirection.CW;
-			}
-		}
 
 		private void CreateVerticesFromPoints()
 		{
@@ -473,7 +415,7 @@ private void CreateVerticesFromPoints()
 			firstVertex.SetPreviousVertex(eachVertex);
 		}
 
-		private void CreateEdgesConnectingPoints()
+		void CreateEdgesConnectingPoints()
 		{
 			// Enumerate vertices.
 			Edge eachEdge = null;
@@ -708,10 +650,9 @@ private Polygon PolygonFromClipperPath(Path path, float scale)
 
 	#region Geometry features (Transformations)
 
-		public void RecalculateWindindDirection()
+		public void Reverse()
 		{
-			_windingDirection = WindingDirection.Unknown;
-			CalculateWindingDirectionIfNeeded();
+			// May be a feature later on (reverse `_points` using `System.Array.Copy()`.
 		}
 
 		public void AlignCentered()
@@ -736,9 +677,7 @@ public void Translate(Vector2 translation)
 			}
 
 			// Polygon calculations.
-			CalculateBounds();
-			CalculateArea();
-			CalculateCentroid();
+			Calculate();
 
 			// Update (bounds).
 			// _bounds.position += translation;
@@ -762,9 +701,7 @@ public void Scale(Vector2 scale)
 			}
 
 			// Polygon calculations.
-			CalculateBounds();
-			CalculateArea();
-			CalculateCentroid();
+			Calculate();
 		}
 
 	#endregion

README.md

@@ -3,7 +3,7 @@
 
 **📐 2D geometry for Unity.**
 
-Polygon triangulation, Voronoi diagram, polygon offset, polygon outline, union of polygons, substraction of polygons. polygon clipping, polygon winding direction, polygon area, polygon centroid, centroid of multiple polygons, line intersection, point-line distance, segment intersection, polygon-point containment, and more.
+Polygon clipping, polygon winding direction, polygon area, polygon centroid, centroid of multiple polygons, line intersection, point-line distance, segment intersection, polygon-point containment, polygon triangulation, polygon Voronoi diagram, polygon offset, polygon outline, polygon buffer, polygon union, polygon substraction, polygon boolean operations, and more. It is a polygon fest.
 
 The library is **being used in production**. However, it comes with the disclaimed liability and warranty of [MIT License](https://en.wikipedia.org/wiki/MIT_License).