NonCollidingPrimitives()
25 | {
26 | yield return new object[] { new Point(10, 10), Point.Zero };
27 | yield return new object[] { new Point(10, 10), Circle.Unit };
28 | yield return new object[] { new Point(10, 10), Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One) };
29 | yield return new object[] { new Point(10, 10), new PolyLine(0, 0, 1, 1) };
30 | }
31 |
32 | [Benchmark]
33 | [ArgumentsSource(nameof(CollidingPrimitives))]
34 | public bool PointCollision(Primitive a, Primitive b)
35 | {
36 | return a.CollidesWithPrimitive(b);
37 | }
38 |
39 | [Benchmark]
40 | [ArgumentsSource(nameof(NonCollidingPrimitives))]
41 | public bool PointNonCollision(Primitive a, Primitive b)
42 | {
43 | return a.CollidesWithPrimitive(b);
44 | }
45 | }
--------------------------------------------------------------------------------
/Benchmarks/Program.cs:
--------------------------------------------------------------------------------
1 | using BenchmarkDotNet.Running;
2 |
3 | namespace Aptacode.Geometry.Benchmarks;
4 |
5 | internal static class Program
6 | {
7 | private static int Main(string[] args)
8 | {
9 | BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly)
10 | .Run(args, new FastAndDirtyConfig());
11 |
12 | return 0;
13 | }
14 | }
--------------------------------------------------------------------------------
/Demo/App.razor:
--------------------------------------------------------------------------------
1 |
2 |
3 |
6 |
7 | Not found
8 |
9 | Sorry, there's nothing at this address.
10 |
11 |
12 |
--------------------------------------------------------------------------------
/Demo/Demo.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | net7.0
5 | enable
6 | enable
7 | Aptacode.Geometry.Demo
8 |
9 |
10 |
11 |
15 |
16 |
17 |
19 |
20 |
--------------------------------------------------------------------------------
/Demo/Pages/Ascii.razor:
--------------------------------------------------------------------------------
1 | @page "/ascii"
2 | @inherits AsciiBase
3 |
4 | Ascii Representations
5 |
6 | Ascii Geometry
7 | This tool is for generating the ascii representation of various geometric primitives for use in our collision unit tests.
8 |
10 | Enter your primitive e.g
16 | Enter the output size
20 | {
27 | @for (var j = 0; j < Output.GetLength(1); j++)
28 | {
29 | @((MarkupString)$"{Output[i, j]}, ")
30 | }
31 | },
32 | Geometry Profile
5 |
6 | Click 'run' to profile the methods on various primitives. Each function is ran in 10 batches of 100 executions.
7 |
8 | Run
9 | Group
10 | Fastest
11 | Slowest
12 |
13 |
14 |
15 | Title
16 | Fastest (ms)
17 | Slowest (ms)
18 | Average (ms)
19 |
20 | @foreach (var result in Results)
21 | {
22 |
23 | @result.Title
24 | @result.Fastest.ToString("G3")
25 | @result.Slowest.ToString("G3")
26 | @result.Average.ToString("G3")
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/Demo/Pages/Benchmark/Benchmark.razor.cs:
--------------------------------------------------------------------------------
1 | using Microsoft.AspNetCore.Components;
2 |
3 | namespace Aptacode.Geometry.Demo.Pages.Benchmark;
4 |
5 | public class BenchmarkBase : ComponentBase
6 | {
7 | private string _order = "Group";
8 |
9 | #region Properties
10 |
11 | protected IEnumerable Results = new List();
12 |
13 | #endregion
14 |
15 | #region Dependencies
16 |
17 | [Inject] public ILogger Logger { get; set; } = null!;
18 |
19 | #endregion
20 |
21 | protected void RunOnClick()
22 | {
23 | var runner = new ProfileRunner(GeometryProfileFunctions.GeometryFunctions());
24 | Results = runner.Run(10, 100);
25 | OrderResults();
26 |
27 | StateHasChanged();
28 | }
29 |
30 | private void OrderResults()
31 | {
32 | Results = _order switch
33 | {
34 | "Group" => Results.OrderByDescending(r => r.Title),
35 | "Fastest" => Results.OrderBy(r => r.Average),
36 | "Slowest" => Results.OrderByDescending(r => r.Average),
37 | _ => Results
38 | };
39 | }
40 |
41 | protected void OrderByGroup()
42 | {
43 | _order = "Group";
44 | OrderResults();
45 | StateHasChanged();
46 | }
47 |
48 | protected void OrderByFastest()
49 | {
50 | _order = "Fastest";
51 | OrderResults();
52 | StateHasChanged();
53 | }
54 |
55 | protected void OrderBySlowest()
56 | {
57 | _order = "Slowest";
58 | OrderResults();
59 | StateHasChanged();
60 | }
61 | }
--------------------------------------------------------------------------------
/Demo/Pages/Benchmark/GeometryProfileFunctions.cs:
--------------------------------------------------------------------------------
1 | using System.Numerics;
2 | using Aptacode.Geometry.Primitives;
3 |
4 | namespace Aptacode.Geometry.Demo.Pages.Benchmark;
5 |
6 | public static class GeometryProfileFunctions
7 | {
8 | public static IReadOnlyList GeometryFunctions()
9 | {
10 | return new ProfileFunction[]
11 | {
12 | //Ellipse
13 | new PrimitiveCreation(),
14 | new PrimitiveFunction(f => f.Rotate(10), "rotate"),
15 | new PrimitiveFunction(f => f.Scale(Vector2.One, new Vector2(10, 5)), "scale"),
16 | new PrimitiveFunction(f => f.Skew(new Vector2(10, 5)), "skew"),
17 | new PrimitiveFunction(f => f.Translate(new Vector2(10, 5)), "translate"),
18 | new PrimitiveFunction(f => f.CollidesWith(new Vector2(10, 5)), "point collision"),
19 |
20 | //Point
21 | new PrimitiveCreation(),
22 | new PrimitiveFunction(f => f.Rotate(10), "rotate"),
23 | new PrimitiveFunction(f => f.Scale(Vector2.One, new Vector2(10, 5)), "scale"),
24 | new PrimitiveFunction(f => f.Skew(new Vector2(10, 5)), "skew"),
25 | new PrimitiveFunction(f => f.Translate(new Vector2(10, 5)), "translate"),
26 | new PrimitiveFunction(f => f.CollidesWith(new Vector2(10, 5)), "point collision"),
27 |
28 | //PolyLine
29 | new PrimitiveCreation(),
30 | new PrimitiveFunction(f => f.Rotate(10), "rotate"),
31 | new PrimitiveFunction(f => f.Scale(Vector2.One, new Vector2(10, 5)), "scale"),
32 | new PrimitiveFunction(f => f.Skew(new Vector2(10, 5)), "skew"),
33 | new PrimitiveFunction(f => f.Translate(new Vector2(10, 5)), "translate"),
34 | new PrimitiveFunction(f => f.CollidesWith(new Vector2(10, 5)), "point collision"),
35 |
36 | //Polygon
37 | new PrimitiveCreation(),
38 | new PrimitiveFunction(f => f.Rotate(10), "rotate"),
39 | new PrimitiveFunction(f => f.Scale(Vector2.One, new Vector2(10, 5)), "scale"),
40 | new PrimitiveFunction(f => f.Skew(new Vector2(10, 5)), "skew"),
41 | new PrimitiveFunction(f => f.Translate(new Vector2(10, 5)), "translate"),
42 | new PrimitiveFunction(f => f.CollidesWith(new Vector2(10, 5)), "point collision"),
43 | };
44 | }
45 | }
--------------------------------------------------------------------------------
/Demo/Pages/Benchmark/PrimitiveCreation.cs:
--------------------------------------------------------------------------------
1 | using Aptacode.Geometry.Primitives;
2 |
3 | namespace Aptacode.Geometry.Demo.Pages.Benchmark;
4 |
5 | public class PrimitiveCreation : ProfileFunction where T : Primitive
6 | {
7 | private readonly Func _createPrimitive;
8 | private readonly string _primitiveName;
9 | private Random _random = new(0);
10 |
11 | public PrimitiveCreation()
12 | {
13 | var type = typeof(T);
14 | _primitiveName = type.Name;
15 |
16 | if (type == typeof(Circle))
17 | {
18 | _createPrimitive = r => ProfileHelpers.CreateEllipse(r) as T;
19 | }
20 | else if (type == typeof(Point))
21 | {
22 | _createPrimitive = r => ProfileHelpers.CreatePoint(r) as T;
23 | }
24 | else if (type == typeof(Polygon))
25 | {
26 | _createPrimitive = r => ProfileHelpers.CreatePolygon(r) as T;
27 | }
28 | else if (type == typeof(PolyLine))
29 | {
30 | _createPrimitive = r => ProfileHelpers.CreatePolyline(r) as T;
31 | }
32 |
33 | if (_createPrimitive == null)
34 | {
35 | throw new ArgumentNullException();
36 | }
37 | }
38 |
39 | public override string Title()
40 | {
41 | return $"{_primitiveName} creation";
42 | }
43 |
44 | public override void Setup()
45 | {
46 | _random = new Random(0);
47 | }
48 |
49 | public override void Run()
50 | {
51 | _createPrimitive(_random);
52 | }
53 | }
--------------------------------------------------------------------------------
/Demo/Pages/Benchmark/PrimitiveFunction.cs:
--------------------------------------------------------------------------------
1 | using Aptacode.Geometry.Primitives;
2 |
3 | namespace Aptacode.Geometry.Demo.Pages.Benchmark;
4 |
5 | public class PrimitiveFunction : ProfileFunction where T : Primitive
6 | {
7 | private readonly Func _createPrimitive;
8 | private readonly string _operationName;
9 | private readonly string _primitiveName;
10 | private readonly Action _primitiveOperation;
11 | private T _primitive;
12 | private Random _random;
13 |
14 | public PrimitiveFunction(Action primitiveOperation, string operationName)
15 | {
16 | var type = typeof(T);
17 | _primitiveName = type.Name;
18 | _operationName = operationName;
19 |
20 | if (type == typeof(Circle))
21 | {
22 | _createPrimitive = r => ProfileHelpers.CreateEllipse(r) as T;
23 | }
24 | else if (type == typeof(Point))
25 | {
26 | _createPrimitive = r => ProfileHelpers.CreatePoint(r) as T;
27 | }
28 | else if (type == typeof(Polygon))
29 | {
30 | _createPrimitive = r => ProfileHelpers.CreatePolygon(r) as T;
31 | }
32 | else if (type == typeof(PolyLine))
33 | {
34 | _createPrimitive = r => ProfileHelpers.CreatePolyline(r) as T;
35 | }
36 |
37 | if (_createPrimitive == null)
38 | {
39 | throw new ArgumentNullException();
40 | }
41 |
42 | _primitiveOperation = primitiveOperation;
43 | }
44 |
45 | public override string Title()
46 | {
47 | return $"{_primitiveName} {_operationName}";
48 | }
49 |
50 | public override void Setup()
51 | {
52 | _random = new Random(0);
53 | }
54 |
55 | public override void Reset()
56 | {
57 | _primitive = _createPrimitive(_random);
58 | }
59 |
60 | public override void Run()
61 | {
62 | _primitiveOperation(_primitive);
63 | }
64 | }
--------------------------------------------------------------------------------
/Demo/Pages/Benchmark/ProfileFunction.cs:
--------------------------------------------------------------------------------
1 | namespace Aptacode.Geometry.Demo.Pages.Benchmark;
2 |
3 | public abstract class ProfileFunction
4 | {
5 | public abstract string Title();
6 |
7 | public virtual void Setup()
8 | {
9 | }
10 |
11 | public virtual void Reset()
12 | {
13 | }
14 |
15 | public abstract void Run();
16 | }
--------------------------------------------------------------------------------
/Demo/Pages/Benchmark/ProfileFunctionResult.cs:
--------------------------------------------------------------------------------
1 | namespace Aptacode.Geometry.Demo.Pages.Benchmark;
2 |
3 | public record ProfileFunctionResult(string Title, IReadOnlyList Elapsed)
4 | {
5 | public double Fastest => Elapsed.Min();
6 | public double Slowest => Elapsed.Max();
7 | public double Average => Elapsed.Average();
8 | }
--------------------------------------------------------------------------------
/Demo/Pages/Benchmark/ProfileHelpers.cs:
--------------------------------------------------------------------------------
1 | using System.Numerics;
2 | using Aptacode.Geometry.Primitives;
3 |
4 | namespace Aptacode.Geometry.Demo.Pages.Benchmark;
5 |
6 | public static class ProfileHelpers
7 | {
8 | public static Circle CreateEllipse(Random r)
9 | {
10 | return new Circle(r.Next(), r.Next(), r.Next());
11 | }
12 |
13 |
14 | public static Point CreatePoint(Random r)
15 | {
16 | return new Point(r.Next(), r.Next());
17 | }
18 |
19 |
20 | public static Polygon CreatePolygon(Random r)
21 | {
22 | var points = new Vector2[r.Next(1, 10)];
23 | for (var i = 0; i < points.Length; i++)
24 | {
25 | points[i] = new Vector2(r.Next(), r.Next());
26 | }
27 |
28 | return new Polygon(points);
29 | }
30 |
31 | public static PolyLine CreatePolyline(Random r)
32 | {
33 | var points = new Vector2[r.Next(1, 10)];
34 | for (var i = 0; i < points.Length; i++)
35 | {
36 | points[i] = new Vector2(r.Next(), r.Next());
37 | }
38 |
39 | return PolyLine.Create(points);
40 | }
41 | }
--------------------------------------------------------------------------------
/Demo/Pages/Benchmark/ProfileRunner.cs:
--------------------------------------------------------------------------------
1 | using System.Diagnostics;
2 |
3 | namespace Aptacode.Geometry.Demo.Pages.Benchmark;
4 |
5 | public class ProfileRunner
6 | {
7 | private readonly IReadOnlyList _profileFunctions;
8 |
9 | public ProfileRunner(IReadOnlyList profileFunctions)
10 | {
11 | _profileFunctions = profileFunctions;
12 | }
13 |
14 | public List Run(int batchCount, int batchSize)
15 | {
16 | var results = new List();
17 |
18 | foreach (var profileFunction in _profileFunctions)
19 | {
20 | //Warmup
21 | profileFunction.Setup();
22 | for (var i = 0; i < 10; i++)
23 | {
24 | profileFunction.Reset();
25 | profileFunction.Run();
26 | }
27 |
28 | //Actual Run
29 | var stopWatch = new Stopwatch();
30 | var functionDurations = new List();
31 | profileFunction.Setup();
32 |
33 | for (var i = 0; i < batchCount; i++)
34 | {
35 | stopWatch.Restart();
36 |
37 | for (var j = 0; j < batchSize; j++)
38 | {
39 | profileFunction.Reset();
40 |
41 | profileFunction.Run();
42 | }
43 |
44 | stopWatch.Stop();
45 | functionDurations.Add(stopWatch.Elapsed.TotalMilliseconds / batchCount);
46 | }
47 |
48 | results.Add(new ProfileFunctionResult(profileFunction.Title(), functionDurations));
49 | }
50 |
51 | return results;
52 | }
53 | }
--------------------------------------------------------------------------------
/Demo/Pages/Canvas.razor:
--------------------------------------------------------------------------------
1 | @page "/canvas"
2 | @inherits CanvasBase
3 |
4 | Canvas Representations
5 |
6 |
11 |
12 |
13 |
14 |
15 |
17 |
18 |
21 |
22 |
24 |
25 |
26 |
29 |
Geometry
--------------------------------------------------------------------------------
/Demo/Pages/Index.razor.cs:
--------------------------------------------------------------------------------
1 | using Aptacode.Geometry.Demo.Pages.Benchmark;
2 | using Microsoft.AspNetCore.Components;
3 |
4 | namespace Aptacode.Geometry.Demo.Pages;
5 |
6 | public class IndexBase : ComponentBase
7 | {
8 | private string _order = "Group";
9 |
10 | #region Properties
11 |
12 | protected IEnumerable Results = new List();
13 |
14 | #endregion
15 |
16 | #region Dependencies
17 |
18 | [Inject] public ILogger Logger { get; set; } = null!;
19 |
20 | #endregion
21 |
22 | protected void RunOnClick()
23 | {
24 | var runner = new ProfileRunner(GeometryProfileFunctions.GeometryFunctions());
25 | Results = runner.Run(10, 100);
26 | OrderResults();
27 |
28 | StateHasChanged();
29 | }
30 |
31 | private void OrderResults()
32 | {
33 | Results = _order switch
34 | {
35 | "Group" => Results.OrderByDescending(r => r.Title),
36 | "Fastest" => Results.OrderBy(r => r.Average),
37 | "Slowest" => Results.OrderByDescending(r => r.Average),
38 | _ => Results
39 | };
40 | }
41 |
42 | protected void OrderByGroup()
43 | {
44 | _order = "Group";
45 | OrderResults();
46 | StateHasChanged();
47 | }
48 |
49 | protected void OrderByFastest()
50 | {
51 | _order = "Fastest";
52 | OrderResults();
53 | StateHasChanged();
54 | }
55 |
56 | protected void OrderBySlowest()
57 | {
58 | _order = "Slowest";
59 | OrderResults();
60 | StateHasChanged();
61 | }
62 | }
--------------------------------------------------------------------------------
/Demo/Program.cs:
--------------------------------------------------------------------------------
1 | using Aptacode.Geometry.Demo;
2 | using Microsoft.AspNetCore.Components.Web;
3 | using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
4 |
5 | var builder = WebAssemblyHostBuilder.CreateDefault(args);
6 | builder.RootComponents.Add("#app");
7 | builder.RootComponents.Add("head::after");
8 |
9 | builder.Services.AddScoped(sp => new HttpClient { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });
10 |
11 | await builder.Build().RunAsync();
--------------------------------------------------------------------------------
/Demo/Properties/launchSettings.json:
--------------------------------------------------------------------------------
1 | {
2 | "iisSettings": {
3 | "windowsAuthentication": false,
4 | "anonymousAuthentication": true,
5 | "iisExpress": {
6 | "applicationUrl": "http://localhost:51213",
7 | "sslPort": 44360
8 | }
9 | },
10 | "profiles": {
11 | "Demo": {
12 | "commandName": "Project",
13 | "dotnetRunMessages": true,
14 | "launchBrowser": true,
15 | "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}",
16 | "applicationUrl": "https://localhost:7231;http://localhost:5231",
17 | "environmentVariables": {
18 | "ASPNETCORE_ENVIRONMENT": "Development"
19 | }
20 | },
21 | "IIS Express": {
22 | "commandName": "IISExpress",
23 | "launchBrowser": true,
24 | "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}",
25 | "environmentVariables": {
26 | "ASPNETCORE_ENVIRONMENT": "Development"
27 | }
28 | }
29 | }
30 | }
--------------------------------------------------------------------------------
/Demo/Shared/MainLayout.razor:
--------------------------------------------------------------------------------
1 | @inherits LayoutComponentBase
2 |
3 |
4 |
5 |
6 |
26 |
27 |
28 | @Body
29 |
30 |
` *tag and a unique class name for each different icon in the* `` *tag.*
37 |
38 | ```
39 |
40 |
42 | ```
43 |
44 | Sizing icons only needs basic CSS. All the icons are in a square format, so just set the `` tag with equal width and height dimensions.
45 |
46 | ```
47 | .icon {
48 | width: 16px;
49 | height: 16px;
50 | }
51 | ```
52 |
53 | Coloring icons is even easier. All you need to do is set the `fill` rule on the `` tag.
54 |
55 | ```
56 | .icon-account-login {
57 | fill: #f00;
58 | }
59 | ```
60 |
61 | To learn more about SVG Sprites, read [Chris Coyier's guide](http://css-tricks.com/svg-sprites-use-better-icon-fonts/).
62 |
63 | #### Using Open Iconic's Icon Font...
64 |
65 |
66 | ##### …with Bootstrap
67 |
68 | You can find our Bootstrap stylesheets in `font/css/open-iconic-bootstrap.{css, less, scss, styl}`
69 |
70 |
71 | ```
72 | Demo
8 | Loading...
15 |
16 |
17 | An unhandled error has occurred.
18 |
Reload
19 |
🗙
20 |
2 |
3 |
4 | net7.0
5 | Aptacode
6 | true
7 | 1.2.3
8 | 1.2.3
9 | 1.2.3
10 | Logo.png
11 | https://github.com/Aptacode/Geometry
12 | Logo.ico
13 | https://github.com/Aptacode/Geometry
14 | High performance .net geometry library
15 | Aptacode.Geometry
16 | Aptacode.Geometry
17 |
18 |
19 |
20 |
23 |
24 |
25 |
26 | True
27 |
29 |
30 |
31 |
--------------------------------------------------------------------------------
/Geometry/Logo.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Aptacode/Geometry/b61a409286a742fa6a8f705535e2ccb1842a6cf9/Geometry/Logo.ico
--------------------------------------------------------------------------------
/Geometry/Primitives/Circle.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Numerics;
3 | using Aptacode.Geometry.Collision;
4 |
5 | namespace Aptacode.Geometry.Primitives;
6 |
7 | public sealed class Circle : Primitive
8 | {
9 | #region Properties
10 |
11 | public float Radius { get; protected set; }
12 | public Vector2 Position { get; protected set; }
13 | public override Vector2 GetCentroid() => Position;
14 |
15 | #endregion
16 |
17 | #region Construction
18 |
19 | public Circle(Vector2 position, float radius)
20 | {
21 | Position = position;
22 | Radius = radius;
23 | }
24 | public Circle(float x, float y, float radius)
25 | {
26 | Position = new Vector2(x,y);
27 | Radius = radius;
28 | }
29 |
30 | public static Circle Zero => new(Vector2.Zero, 0.0f);
31 | public static Circle Unit => new(Vector2.Zero, 1.0f);
32 |
33 | #endregion
34 | public override string ToString()
35 | {
36 | return $"Circle ({Position.X},{Position.Y}), {Radius}";
37 | }
38 |
39 | #region Collision Detection
40 |
41 | public override bool CollidesWith(Vector2 p)
42 | {
43 | return Vector2CollisionDetectionMethods.CollidesWith(this, p);
44 | }
45 |
46 | public override bool CollidesWith(Point p)
47 | {
48 | return PrimitiveCollisionDetectionMethods.CollidesWith(p, this);
49 | }
50 |
51 | public override bool CollidesWith(Circle p)
52 | {
53 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
54 | }
55 |
56 | public override bool CollidesWith(PolyLine p)
57 | {
58 | return PrimitiveCollisionDetectionMethods.CollidesWith(p, this);
59 | }
60 |
61 | public override bool CollidesWith(Polygon p)
62 | {
63 | return PrimitiveCollisionDetectionMethods.CollidesWith(p, this);
64 | }
65 |
66 | #endregion
67 |
68 | #region Transformations
69 |
70 | public override Circle Translate(Vector2 delta)
71 | {
72 | Position += delta;
73 | return this;
74 | }
75 |
76 | public override Circle ScaleAboutCenter(Vector2 delta)
77 | {
78 | return this;
79 | }
80 |
81 | public override Circle Rotate(float theta)
82 | {
83 | return this;
84 | }
85 |
86 | public override Circle Rotate(Vector2 rotationCenter, float theta)
87 | {
88 | return this;
89 | }
90 |
91 | public override Circle Skew(Vector2 delta)
92 | {
93 | return this;
94 | }
95 |
96 | public override Circle Scale(Vector2 scaleCenter, Vector2 delta)
97 | {
98 |
99 | return this;
100 | }
101 |
102 |
103 | #endregion
104 |
105 | public override Circle Transform(Matrix3x2 matrix)
106 | {
107 | Position = Vector2.Transform(Position, matrix);
108 | return this;
109 | }
110 |
111 | public override Circle Copy()
112 | {
113 | return new Circle(Position, Radius);
114 | }
115 |
116 | public void CopyTo(Circle destination)
117 | {
118 | destination.Position = Position;
119 | destination.Radius = Radius;
120 | }
121 | public void CopyAndTransformTo(Circle destination, Matrix3x2 matrix)
122 | {
123 | destination.Position = Vector2.Transform(Position, matrix);
124 | destination.Radius = Radius;
125 | }
126 |
127 | public override bool AreEqual(Primitive other)
128 | {
129 | if (other == null)
130 | {
131 | return false;
132 | }
133 |
134 | if (other is not Circle otherEllipse)
135 | {
136 | return false;
137 | }
138 |
139 | if (Math.Abs(Radius - otherEllipse.Radius) > Constants.Tolerance)
140 | {
141 | return false;
142 | }
143 |
144 | var delta = Position - otherEllipse.Position;
145 | return Math.Abs(delta.X + delta.Y) < Constants.Tolerance;
146 | }
147 | }
--------------------------------------------------------------------------------
/Geometry/Primitives/Point.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Numerics;
3 | using Aptacode.Geometry.Collision;
4 |
5 | namespace Aptacode.Geometry.Primitives;
6 |
7 | public sealed class Point : Primitive
8 | {
9 | #region Properties
10 |
11 | public Vector2 Position { get; set; }
12 | public override Vector2 GetCentroid()
13 | {
14 | return Position;
15 | }
16 |
17 | #endregion
18 |
19 | public override string ToString() => $"Point ({Position.X},{Position.Y})";
20 | #region IEquatable
21 |
22 | public override Point Transform(Matrix3x2 matrix)
23 | {
24 | Position = Vector2.Transform(Position, matrix);
25 | return this;
26 | }
27 |
28 | public override Point Copy() => new(Position);
29 | public void CopyTo(Point destination)
30 | {
31 | destination.Position = Position;
32 | }
33 | public void CopyAndTransformTo(Point destination, Matrix3x2 matrix)
34 | {
35 | destination.Position = Vector2.Transform(Position, matrix);
36 | }
37 |
38 | public override bool AreEqual(Primitive other)
39 | {
40 | if (other == null || other is not Point otherPoint)
41 | {
42 | return false;
43 | }
44 |
45 | return Math.Abs(Position.X - otherPoint.Position.X) < Constants.Tolerance &&
46 | Math.Abs(Position.Y - otherPoint.Position.Y) < Constants.Tolerance;
47 | }
48 |
49 | #endregion
50 |
51 | #region Collision Detection
52 |
53 | public override bool CollidesWith(Vector2 p)
54 | {
55 | return Vector2CollisionDetectionMethods.CollidesWith(this, p);
56 | }
57 |
58 | public override bool CollidesWith(Point p)
59 | {
60 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
61 | }
62 |
63 | public override bool CollidesWith(Circle p)
64 | {
65 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
66 | }
67 |
68 | public override bool CollidesWith(PolyLine p)
69 | {
70 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
71 | }
72 |
73 | public override bool CollidesWith(Polygon p)
74 | {
75 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
76 | }
77 |
78 | #endregion
79 |
80 | #region Construction
81 |
82 | public Point(Vector2 position)
83 | {
84 | Position = position;
85 | }
86 | public Point(float x, float y)
87 | {
88 | Position = new Vector2(x,y);
89 | }
90 |
91 | public override Point Translate(Vector2 delta)
92 | {
93 | Position += delta;
94 | return this;
95 | }
96 |
97 | public override Point Rotate(float theta)
98 | {
99 | return this;
100 | }
101 |
102 | public override Point Rotate(Vector2 rotationCenter, float theta)
103 | {
104 | return this;
105 | }
106 |
107 | public override Point ScaleAboutCenter(Vector2 delta)
108 | {
109 | return this;
110 | }
111 |
112 | public override Point Scale(Vector2 scaleCenter, Vector2 delta)
113 | {
114 | return this;
115 | }
116 |
117 | public override Point Skew(Vector2 delta)
118 | {
119 | return this;
120 | }
121 |
122 | public static Point Zero => new(Vector2.Zero);
123 | public static Point Unit => new(Vector2.One);
124 |
125 | #endregion
126 | }
--------------------------------------------------------------------------------
/Geometry/Primitives/PolyLine.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Linq;
3 | using System.Numerics;
4 | using System.Runtime.CompilerServices;
5 | using Aptacode.Geometry.Collision;
6 | using Aptacode.Geometry.Vertices;
7 |
8 | namespace Aptacode.Geometry.Primitives;
9 |
10 | public sealed class PolyLine : Primitive
11 | {
12 | public override string ToString()
13 | {
14 | return $"PolyLine {Vertices.Print()}";
15 | }
16 |
17 | public Vector2[] Vertices { get; set; }
18 |
19 | #region IEquatable
20 |
21 |
22 | public override PolyLine Transform(Matrix3x2 matrix)
23 | {
24 | for(int i = 0; i < Vertices.Length; i++)
25 | {
26 | Vertices[i] = Vector2.Transform(Vertices[i], matrix);
27 | }
28 | return this;
29 | }
30 |
31 | public override PolyLine Copy()
32 | {
33 | var copy = new Vector2[Vertices.Length];
34 | Vertices.CopyTo(copy,0);
35 | return new PolyLine(copy);
36 | }
37 |
38 | public void CopyTo(PolyLine destination)
39 | {
40 | Vertices.CopyTo(destination.Vertices, 0);
41 | destination._updateLineSegments = true;
42 | }
43 | public void CopyAndTransformTo(PolyLine destination, Matrix3x2 matrix)
44 | {
45 | for (int i = 0; i < Vertices.Length; i++)
46 | {
47 | destination.Vertices[i] = Vector2.Transform(Vertices[i], matrix);
48 | }
49 |
50 | destination._updateLineSegments = true;
51 | }
52 |
53 | public override bool AreEqual(Primitive other)
54 | {
55 | return other != null && other is PolyLine otherPolyline && Vertices.AreEqual(otherPolyline.Vertices);
56 | }
57 |
58 | #endregion
59 |
60 | #region Properties
61 |
62 | private bool _updateLineSegments = true;
63 | private readonly (Vector2 P1, Vector2 P2)[] _lineSegments;
64 |
65 | public (Vector2 P1, Vector2 P2)[] LineSegments
66 | {
67 | get
68 | {
69 | if (_updateLineSegments)
70 | {
71 | UpdateLineSegments();
72 | }
73 |
74 | return _lineSegments;
75 | }
76 | }
77 |
78 | public override Vector2 GetCentroid()
79 | {
80 | if(Vertices.Length == 0)
81 | {
82 | return Vector2.Zero;
83 | }
84 |
85 | Span verticesAsSpan = Vertices;
86 | Vector2 v = verticesAsSpan[0];
87 |
88 | for (int i = 1; i < verticesAsSpan.Length; i++)
89 | {
90 | v += verticesAsSpan[i];
91 | }
92 |
93 | return v / verticesAsSpan.Length;
94 | }
95 |
96 | #endregion
97 |
98 | #region Collision Detection
99 |
100 | public override bool CollidesWith(Vector2 p)
101 | {
102 | return Vector2CollisionDetectionMethods.CollidesWith(this, p);
103 | }
104 |
105 | public override bool CollidesWith(Point p)
106 | {
107 | return PrimitiveCollisionDetectionMethods.CollidesWith(p, this);
108 | }
109 |
110 | public override bool CollidesWith(Circle p)
111 | {
112 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
113 | }
114 |
115 | public override bool CollidesWith(PolyLine p)
116 | {
117 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
118 | }
119 |
120 | public override bool CollidesWith(Polygon p)
121 | {
122 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
123 | }
124 |
125 | #endregion
126 |
127 | #region Construction
128 |
129 | public PolyLine(Vector2[] vertices)
130 | {
131 | Vertices = vertices;
132 | _lineSegments = vertices.Length switch
133 | {
134 | 0 => new (Vector2 P1, Vector2 P2)[0], //If no verticies are given there will be no linesegments
135 | 1 => new (Vector2 P1, Vector2 P2)[1], //If one vertex is given make one linesegment with length 0
136 | _ => new (Vector2 P1, Vector2 P2)[vertices.Length -
137 | 1] //If more then 1 vertex is given create n-1 line segments
138 | };
139 | }
140 |
141 | public PolyLine(params float[] points)
142 | {
143 | Vertices = points.FromPoints();
144 | _lineSegments = Vertices.Length switch
145 | {
146 | 0 => new (Vector2 P1, Vector2 P2)[0], //If no verticies are given there will be no linesegments
147 | 1 => new (Vector2 P1, Vector2 P2)[1], //If one vertex is given make one linesegment with length 0
148 | _ => new (Vector2 P1, Vector2 P2)[Vertices.Length -
149 | 1] //If more then 1 vertex is given create n-1 line segments
150 | };
151 | }
152 |
153 | public static readonly PolyLine Zero = Create(Vector2.Zero, Vector2.Zero);
154 |
155 | public static PolyLine Create(params Vector2[] points)
156 | {
157 | var vertexArray = points.ToArray();
158 | return new PolyLine(vertexArray);
159 | }
160 |
161 | #endregion
162 |
163 | #region Transformations
164 |
165 | [MethodImpl(MethodImplOptions.AggressiveInlining)]
166 | private void UpdateLineSegments()
167 | {
168 | _updateLineSegments = false;
169 |
170 | if (Vertices.Length == 0)
171 | {
172 | //If there are no vertices then there can be no linesegments
173 | return;
174 | }
175 |
176 | if (Vertices.Length == 1)
177 | {
178 | //If there is one vertex there will be one line segment with length 0
179 | _lineSegments[0] = (Vertices[0], Vertices[0]);
180 | return;
181 | }
182 |
183 | Span vertexArrayAsSpan = Vertices;
184 | //Get the first vertex
185 | var lastVertex = vertexArrayAsSpan[0];
186 | //Create a line segment for each vertex neighbour pair
187 | for (var i = 1; i <= vertexArrayAsSpan.Length - 1; i++)
188 | {
189 | var nextVertex = vertexArrayAsSpan[i]; //Get the next vertex
190 | LineSegments[i - 1] =
191 | new ValueTuple(lastVertex,
192 | nextVertex); //Create a line segment from the last vertex to the next
193 | lastVertex = nextVertex; //Update the last vertex
194 | }
195 | }
196 | public override PolyLine Translate(Vector2 delta)
197 | {
198 | Vertices.Translate(delta);
199 | _updateLineSegments = true;
200 | return this;
201 | }
202 |
203 | public override PolyLine Rotate(float theta)
204 | {
205 | var center = GetCentroid();
206 | Vertices.Rotate(center, theta);
207 | _updateLineSegments = true;
208 | return this;
209 | }
210 |
211 | public override PolyLine Rotate(Vector2 rotationCenter, float theta)
212 | {
213 | Vertices.Rotate(rotationCenter, theta);
214 | _updateLineSegments = true;
215 | return this;
216 | }
217 |
218 | public override PolyLine ScaleAboutCenter(Vector2 delta)
219 | {
220 | var center = GetCentroid();
221 | Vertices.Scale(center, delta);
222 | _updateLineSegments = true;
223 | return this;
224 | }
225 |
226 | public override PolyLine Scale(Vector2 scaleCenter, Vector2 delta)
227 | {
228 | Vertices.Scale(scaleCenter, delta);
229 | _updateLineSegments = true;
230 | return this;
231 | }
232 |
233 | public override PolyLine Skew(Vector2 delta)
234 | {
235 | Vertices.Skew(delta);
236 | _updateLineSegments = true;
237 | return this;
238 | }
239 |
240 | #endregion
241 | }
--------------------------------------------------------------------------------
/Geometry/Primitives/Polygon.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Numerics;
3 | using System.Runtime.CompilerServices;
4 | using Aptacode.Geometry.Collision;
5 | using Aptacode.Geometry.Vertices;
6 |
7 | namespace Aptacode.Geometry.Primitives;
8 |
9 | public sealed class Polygon : Primitive
10 | {
11 | public override string ToString()
12 | {
13 | return $"Polygon {Vertices.Print()}";
14 | }
15 |
16 | public Vector2[] Vertices { get; set; }
17 |
18 | #region IEquatable
19 | public override Polygon Transform(Matrix3x2 matrix)
20 | {
21 | for (int i = 0; i < Vertices.Length; i++)
22 | {
23 | Vertices[i] = Vector2.Transform(Vertices[i], matrix);
24 | }
25 | return this;
26 | }
27 |
28 | public override Polygon Copy()
29 | {
30 | var copy = new Vector2[Vertices.Length];
31 | Vertices.CopyTo(copy, 0);
32 | return new Polygon(copy);
33 | }
34 | public void CopyTo(Polygon destination)
35 | {
36 | Vertices.CopyTo(destination.Vertices, 0);
37 | destination._updateEdges = true;
38 | }
39 | public void CopyAndTransformTo(Polygon destination, Matrix3x2 matrix)
40 | {
41 | for(int i = 0; i < Vertices.Length; i++)
42 | {
43 | destination.Vertices[i] = Vector2.Transform(Vertices[i], matrix);
44 | }
45 |
46 | destination._updateEdges = true;
47 | }
48 |
49 | public override bool AreEqual(Primitive other)
50 | {
51 | return other != null && other is Polygon otherPolyline && Vertices.AreEqual(otherPolyline.Vertices);
52 | }
53 |
54 | #endregion
55 |
56 | #region Properties
57 |
58 | private bool _updateEdges = true;
59 | private readonly (Vector2 P1, Vector2 P2)[] _edges;
60 |
61 | public (Vector2 P1, Vector2 P2)[] Edges
62 | {
63 | get
64 | {
65 | if (_updateEdges)
66 | {
67 | UpdateEdges();
68 | }
69 |
70 | return _edges;
71 | }
72 | }
73 |
74 | public override Vector2 GetCentroid()
75 | {
76 | float accumulatedArea = 0.0f;
77 | float centerX = 0.0f;
78 | float centerY = 0.0f;
79 |
80 | Span verticesAsSpan = Vertices;
81 | for (int i = 0, j = verticesAsSpan.Length - 1; i< verticesAsSpan.Length; j = i++)
82 | {
83 | float temp = verticesAsSpan[i].X * verticesAsSpan[j].Y - verticesAsSpan[j].X * verticesAsSpan[i].Y;
84 | accumulatedArea += temp;
85 | centerX += (verticesAsSpan[i].X + verticesAsSpan[j].X) * temp;
86 | centerY += (verticesAsSpan[i].Y + verticesAsSpan[j].Y) * temp;
87 | }
88 |
89 | if (Math.Abs(accumulatedArea) < 1E-7f)
90 | return Vector2.Zero; // Avoid division by zero
91 |
92 | accumulatedArea *= 3f;
93 | return new Vector2(centerX / accumulatedArea, centerY / accumulatedArea);
94 | }
95 |
96 | #endregion
97 |
98 | #region Collision Detection
99 |
100 | public override bool CollidesWith(Vector2 p)
101 | {
102 | return Vector2CollisionDetectionMethods.CollidesWith(this, p);
103 | }
104 |
105 | public override bool CollidesWith(Point p)
106 | {
107 | return PrimitiveCollisionDetectionMethods.CollidesWith(p, this);
108 | }
109 |
110 | public override bool CollidesWith(Circle p)
111 | {
112 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
113 | }
114 |
115 | public override bool CollidesWith(PolyLine p)
116 | {
117 | return PrimitiveCollisionDetectionMethods.CollidesWith(p, this);
118 | }
119 |
120 | public override bool CollidesWith(Polygon p)
121 | {
122 | return PrimitiveCollisionDetectionMethods.CollidesWith(this, p);
123 | }
124 |
125 | #endregion
126 |
127 | #region Construction
128 |
129 | public Polygon(params Vector2[] vertices)
130 | {
131 | Vertices = vertices;
132 | _edges = new (Vector2 P1, Vector2 P2)[vertices.Length];
133 | }
134 |
135 | public Polygon(params float[] vertices)
136 | {
137 | Vertices = vertices.FromPoints();
138 | _edges = new (Vector2 P1, Vector2 P2)[vertices.Length];
139 | }
140 |
141 | public static class Rectangle
142 | {
143 | public static Polygon FromTwoPoints(Vector2 a, Vector2 b)
144 | {
145 | var minX = a.X;
146 | var maxX = b.X;
147 | var minY = a.Y;
148 | var maxY = b.Y;
149 | if (a.X > b.X)
150 | {
151 | minX = b.X;
152 | maxX = a.X;
153 | }
154 |
155 | if (a.Y > b.Y)
156 | {
157 | minY = b.Y;
158 | maxY = a.Y;
159 | }
160 |
161 | return new Polygon(new Vector2[] { new Vector2(minX, minY), new Vector2(minX, maxY), new Vector2(maxX, maxY),
162 | new Vector2(maxX, minY) });
163 | }
164 | }
165 |
166 | #endregion
167 |
168 | #region Transformations
169 |
170 | [MethodImpl(MethodImplOptions.AggressiveInlining)]
171 | private void UpdateEdges()
172 | {
173 | _updateEdges = false;
174 |
175 | var lastVertex = Vector2.Zero;
176 | for (var i = 0; i < Vertices.Length; i++)
177 | {
178 | var vertex = Vertices[i];
179 | if (i > 0)
180 | {
181 | _edges[i - 1] = new ValueTuple(lastVertex, vertex);
182 | }
183 |
184 | lastVertex = vertex;
185 | }
186 |
187 | _edges[^1] = new ValueTuple(lastVertex, Vertices[0]);
188 | }
189 |
190 | public override Polygon Translate(Vector2 delta)
191 | {
192 | Vertices.Translate(delta);
193 | _updateEdges = true;
194 | return this;
195 | }
196 |
197 | public override Polygon Rotate(float theta)
198 | {
199 | var center = GetCentroid();
200 | Vertices.Rotate(center, theta);
201 | _updateEdges = true;
202 | return this;
203 | }
204 |
205 | public override Polygon Rotate(Vector2 rotationCenter, float theta)
206 | {
207 | Vertices.Rotate(rotationCenter, theta);
208 | _updateEdges = true;
209 | return this;
210 | }
211 |
212 | public override Polygon ScaleAboutCenter(Vector2 delta)
213 | {
214 | var center = GetCentroid();
215 | Vertices.Scale(center, delta);
216 | _updateEdges = true;
217 | return this;
218 | }
219 |
220 | public override Polygon Scale(Vector2 scaleCenter, Vector2 delta)
221 | {
222 | Vertices.Scale(scaleCenter, delta);
223 | _updateEdges = true;
224 | return this;
225 | }
226 |
227 | public override Polygon Skew(Vector2 delta)
228 | {
229 | Vertices.Skew(delta);
230 | _updateEdges = true;
231 | return this;
232 | }
233 |
234 | #endregion
235 | }
--------------------------------------------------------------------------------
/Geometry/Primitives/Primitive.cs:
--------------------------------------------------------------------------------
1 | using System.Numerics;
2 |
3 | namespace Aptacode.Geometry.Primitives;
4 |
5 | public abstract class Primitive
6 | {
7 | public abstract override string ToString();
8 |
9 | public abstract Vector2 GetCentroid();
10 |
11 | #region Collision Detection
12 |
13 | public abstract bool CollidesWith(Vector2 p);
14 | public abstract bool CollidesWith(Point p);
15 | public abstract bool CollidesWith(Circle p);
16 | public abstract bool CollidesWith(PolyLine p);
17 | public abstract bool CollidesWith(Polygon p);
18 |
19 | public virtual bool CollidesWithPrimitive(Primitive p)
20 | {
21 | return p switch
22 | {
23 | Point point => CollidesWith(point),
24 | Circle ellipse => CollidesWith(ellipse),
25 | PolyLine polyline => CollidesWith(polyline),
26 | Polygon polygon => CollidesWith(polygon)
27 | };
28 | }
29 |
30 | #endregion
31 |
32 | #region Transformations
33 |
34 | public abstract Primitive Transform(Matrix3x2 matrix);
35 | public abstract Primitive Copy();
36 | public abstract bool AreEqual(Primitive other);
37 |
38 | public abstract Primitive Translate(Vector2 delta);
39 |
40 | public abstract Primitive Rotate(float theta);
41 |
42 | public abstract Primitive Rotate(Vector2 rotationCenter, float theta);
43 |
44 | public abstract Primitive ScaleAboutCenter(Vector2 delta);
45 | public abstract Primitive Scale(Vector2 scaleCenter, Vector2 delta);
46 | public abstract Primitive Skew(Vector2 delta);
47 |
48 | #endregion
49 | }
--------------------------------------------------------------------------------
/Geometry/Utilities/Vector2Extensions.cs:
--------------------------------------------------------------------------------
1 | using System.Numerics;
2 | using System.Runtime.CompilerServices;
3 |
4 | namespace Aptacode.Geometry.Utilities;
5 |
6 | public static class Vector2Extensions
7 | {
8 | private static readonly Matrix3x2 RotationMatrix = new(0, -1, 1, 0, 0, 0);
9 |
10 | [MethodImpl(MethodImplOptions.AggressiveInlining)]
11 | public static float VectorCross(this Vector2 a, Vector2 b)
12 | {
13 | return a.X * b.Y - a.Y * b.X;
14 | }
15 |
16 | [MethodImpl(MethodImplOptions.AggressiveInlining)]
17 | public static Vector2 Perp(this Vector2 a)
18 | {
19 | return Vector2.Transform(a, RotationMatrix);
20 | }
21 |
22 | [MethodImpl(MethodImplOptions.AggressiveInlining)]
23 | public static float
24 | PerpDot(this Vector2 a,
25 | Vector2 b) //This is worse than the VectorCross method performance wise for the same result.
26 | {
27 | return Vector2.Dot(a.Perp(), b);
28 | }
29 | }
--------------------------------------------------------------------------------
/Geometry/Vertices/VertexArrayExtensions.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Numerics;
5 | using System.Runtime.CompilerServices;
6 |
7 | namespace Aptacode.Geometry.Vertices;
8 |
9 | public static class VertexArrayExtensions
10 | {
11 |
12 | public static string Print(this Vector2[] verticies)
13 | {
14 | return string.Join(", ", verticies.Select(v => $"({v.X},{v.Y})"));
15 | }
16 |
17 | public static Vector2[] FromPoints(this float[] points)
18 | {
19 | var vertexArray = new Vector2[points.Length / 2];
20 | var vertexIndex = 0;
21 | Span verticesAsSpan = points;
22 | for (var i = 0; i < verticesAsSpan.Length; i += 2)
23 | {
24 | vertexArray[vertexIndex++] = new Vector2(verticesAsSpan[i], verticesAsSpan[i + 1]);
25 | }
26 |
27 | return vertexArray;
28 | }
29 |
30 | public static Vector2[] Concat(this Vector2[] vertexArrayA, Vector2[] vertexArrayB)
31 | {
32 | var newVertices = new Vector2[vertexArrayA.Length + vertexArrayB.Length];
33 | if (newVertices.Length == 0)
34 | {
35 | return newVertices;
36 | }
37 |
38 | var count = 0;
39 | Span vertexArrayAAsSpan = vertexArrayA;
40 | Span vertexArrayBAsSpan = vertexArrayB;
41 |
42 | //Assign first vertex
43 | var lastVertex = newVertices[count++] = vertexArrayA.Length > 0 ? vertexArrayAAsSpan[0] : vertexArrayBAsSpan[0];
44 | for (var i = 1; i < vertexArrayAAsSpan.Length; i++)
45 | {
46 | var nextVertex = vertexArrayAAsSpan[i];
47 | if (lastVertex != nextVertex)
48 | {
49 | newVertices[count++] = nextVertex;
50 | }
51 | }
52 |
53 | for (var i = 0; i < vertexArrayBAsSpan.Length; i++)
54 | {
55 | var nextVertex = vertexArrayBAsSpan[i];
56 | if (lastVertex != nextVertex)
57 | {
58 | newVertices[count++] = nextVertex;
59 | }
60 | }
61 |
62 | //Shrink the array
63 | if (newVertices.Length != count)
64 | {
65 | Array.Resize(ref newVertices, count);
66 | }
67 |
68 | return newVertices;
69 | }
70 |
71 | public static Vector2[] Remove(this Vector2[] vertexArray, int index)
72 | {
73 | var vertices = vertexArray.ToList();
74 | vertices.RemoveAt(index);
75 | return vertices.ToArray();
76 | }
77 |
78 | public static Vector2[] ToConvexHull(this Vector2[] vertexArray, float margin)
79 | {
80 | var newVertices = new Vector2[vertexArray.Length * 4];
81 | var count = 0;
82 |
83 | Span vertexArrayAsSpan = vertexArray;
84 | for (var i = 0; i < vertexArrayAsSpan.Length; i++)
85 | {
86 | var vertex = vertexArrayAsSpan[i];
87 | newVertices[count++] = vertex with { X = vertex.X - margin };
88 | newVertices[count++] = vertex with { X = vertex.X + margin };
89 | newVertices[count++] = vertex with { Y = vertex.Y + margin };
90 | newVertices[count++] = vertex with { Y = vertex.Y - margin };
91 | }
92 |
93 | return newVertices.ToConvexHull(newVertices.Length);
94 | }
95 |
96 | // To find orientation of ordered triplet (p, q, r).
97 | // The function returns following values
98 | // 0 --> p, q and r are colinear
99 | // 1 --> Clockwise
100 | // 2 --> Counterclockwise
101 | [MethodImpl(MethodImplOptions.AggressiveInlining)]
102 | public static int Orientation(Vector2 p, Vector2 q, Vector2 r)
103 | {
104 | var val = (q.Y - p.Y) * (r.X - q.X) - (q.X - p.X) * (r.Y - q.Y);
105 |
106 | if (val == 0)
107 | {
108 | return 0; // collinear
109 | }
110 |
111 | return val > 0 ? 1 : 2; // clock or counterclock wise
112 | }
113 |
114 | // finds the Vector2 array that defines the convex hull of a set of n points.
115 | public static Vector2[] ToConvexHull(this Vector2[] points, int n)
116 | {
117 | // There must be at least 3 points
118 | if (n < 3)
119 | {
120 | return Array.Empty();
121 | }
122 |
123 | // Initialize Result
124 | var hull = new List();
125 |
126 | // Find the leftmost point
127 | var l = 0;
128 | Span pointsAsSpan = points;
129 | for (var i = 1; i < n; i++)
130 | {
131 | if (pointsAsSpan[i].X < pointsAsSpan[l].X)
132 | {
133 | l = i;
134 | }
135 | }
136 |
137 | // Start from leftmost point, keep moving
138 | // counterclockwise until reach the start point
139 | // again. This loop runs O(h) times where h is
140 | // number of points in result or output.
141 | int p = l, q;
142 | do
143 | {
144 | // Add current point to result
145 | hull.Add(pointsAsSpan[p]);
146 |
147 | // Search for a point 'q' such that
148 | // orientation(p, x, q) is counterclockwise
149 | // for all points 'x'. The idea is to keep
150 | // track of last visited most counterclock-
151 | // wise point in q. If any point 'i' is more
152 | // counterclock-wise than q, then update q.
153 | q = (p + 1) % n;
154 |
155 | for (var i = 0; i < n; i++)
156 | // If i is more counterclockwise than
157 | // current q, then update q
158 | {
159 | if (Orientation(pointsAsSpan[p], pointsAsSpan[i], pointsAsSpan[q])
160 | == 2)
161 | {
162 | q = i;
163 | }
164 | }
165 |
166 | // Now q is the most counterclockwise with
167 | // respect to p. Set p as q for next iteration,
168 | // so that q is added to result 'hull'
169 | p = q;
170 |
171 | // point
172 | } while (p != l); // While we don't come to first
173 |
174 | return hull.ToArray();
175 | }
176 |
177 | [MethodImpl(MethodImplOptions.AggressiveInlining)]
178 | public static Vector2[] OrderClockwiseFromLeastX(this Vector2[] vertexArray)
179 | {
180 | var minX = float.MaxValue;
181 | var minXindex = -1;
182 | Span vertexArrayAsSpan = vertexArray;
183 | for (var i = 0; i < vertexArrayAsSpan.Length; i++)
184 | {
185 | if (vertexArrayAsSpan[i].X > minX)
186 | {
187 | continue;
188 | }
189 |
190 | if (Math.Abs(vertexArrayAsSpan[i].X - minX) >= Constants.Tolerance)
191 | {
192 | minX = vertexArrayAsSpan[i].X;
193 | minXindex = i;
194 | }
195 | else if
196 | (vertexArrayAsSpan[i].Y <
197 | vertexArray[minXindex]
198 | .Y) //Two points may lie on a horizontal line, we want the one with the lesser y coord then.
199 | {
200 | minX = vertexArrayAsSpan[i].X;
201 | minXindex = i;
202 | }
203 | }
204 |
205 | var clockwiseArray = new Vector2[vertexArray.Length];
206 | Span clockwiseArrayAsSpan = clockwiseArray;
207 |
208 | for (var i = 0;
209 | i < clockwiseArray.Length;
210 | i++) //cyclically permute the vertexArray elements so that the vertex with the least X is first.
211 | {
212 | //probably a better way to do this though.
213 | var j = (minXindex + i) % clockwiseArray.Length; //Need to check this
214 | clockwiseArrayAsSpan[i] = vertexArrayAsSpan[j];
215 | }
216 |
217 | return clockwiseArray;
218 | }
219 |
220 | public static (float,float,float,float) ToBoundingRectangle(this Vector2[] vertexArray)
221 | {
222 | //Exit early if vertex array is empty
223 | if (vertexArray.Length == 0)
224 | {
225 | return (0, 0, 0, 0);
226 | }
227 |
228 | Span vertexArrayAsSpan = vertexArray;
229 |
230 | //Set min / max values to the first vertex
231 | var first = vertexArrayAsSpan[0];
232 | var minX = first.X;
233 | var maxX = first.X;
234 | var minY = first.Y;
235 | var maxY = first.Y;
236 |
237 | for (var i = 1; i < vertexArrayAsSpan.Length; i++)
238 | {
239 | //Transform vertex
240 | var vertex = vertexArrayAsSpan[i];
241 |
242 | //update min / max X values
243 | if (vertex.X < minX)
244 | {
245 | minX = vertex.X;
246 | }
247 | else if (vertex.X > maxX)
248 | {
249 | maxX = vertex.X;
250 | }
251 |
252 | //update min / max Y values
253 | if (vertex.Y < minY)
254 | {
255 | minY = vertex.Y;
256 | }
257 | else if (vertex.Y > maxY)
258 | {
259 | maxY = vertex.Y;
260 | }
261 | }
262 |
263 | return new(minX, minY, maxX, maxY);
264 | }
265 |
266 | #region Transformation
267 |
268 | public static void Transform(this Vector2[] vertexArray, Matrix3x2 transformationMatrix)
269 | {
270 | Span vertexArrayAsSpan = vertexArray;
271 |
272 | //Transform first vertex
273 | var first = vertexArrayAsSpan[0];
274 | vertexArray[0] = first = Vector2.Transform(first, transformationMatrix);
275 |
276 | for (var i = 1; i < vertexArray.Length; i++)
277 | {
278 | //Transform vertex
279 | vertexArrayAsSpan[i] = Vector2.Transform(vertexArrayAsSpan[i], transformationMatrix);
280 | }
281 | }
282 |
283 | public static void Translate(this Vector2[] vertexArray, Vector2 delta)
284 | {
285 | Transform(vertexArray, Matrix3x2.CreateTranslation(delta));
286 | }
287 |
288 | public static void Rotate(this Vector2[] vertexArray, Vector2 rotationCenter, float theta)
289 | {
290 | Transform(vertexArray, Matrix3x2.CreateRotation(theta, rotationCenter));
291 | }
292 |
293 | public static void Scale(this Vector2[] vertexArray, Vector2 scaleCenter, Vector2 delta)
294 | {
295 | Transform(vertexArray, Matrix3x2.CreateScale(delta, scaleCenter));
296 | }
297 |
298 | public static void Skew(this Vector2[] vertexArray, Vector2 delta)
299 | {
300 | Transform(vertexArray, new Matrix3x2(1, delta.Y, delta.X, 1, 0, 0));
301 | }
302 |
303 |
304 | #endregion
305 |
306 |
307 | public static bool AreEqual(this Vector2[] lhs, Vector2[] rhs)
308 | {
309 | if (lhs.Length != rhs.Length)
310 | {
311 | return false;
312 | }
313 |
314 | Span lhsVertices = lhs;
315 | Span rhsVertices = rhs;
316 | for (var i = 0; i < lhsVertices.Length; i++)
317 | {
318 | var delta = lhsVertices[i] - rhsVertices[i];
319 | if (Math.Abs(delta.X) + Math.Abs(delta.Y) > Constants.Tolerance)
320 | {
321 | return false;
322 | }
323 | }
324 |
325 | return true;
326 | }
327 | }
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
635 | Copyright (C)
636 |
637 | This program is free software: you can redistribute it and/or modify
638 | it under the terms of the GNU General Public License as published by
639 | the Free Software Foundation, either version 3 of the License, or
640 | (at your option) any later version.
641 |
642 | This program is distributed in the hope that it will be useful,
643 | but WITHOUT ANY WARRANTY; without even the implied warranty of
644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
645 | GNU General Public License for more details.
646 |
647 | You should have received a copy of the GNU General Public License
648 | along with this program. If not, see Copyright (C)
656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 | This is free software, and you are welcome to redistribute it
658 | under certain conditions; type `show c' for details.
659 |
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License. Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 |
664 | You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | .
675 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 | ### This library is currently being improved and ported over to [DsaDotnet](https://github.com/Timmoth/DsaDotnet) If you would like to get involved please reach out!
3 |
4 |
5 |
6 |
7 |
10 | {
11 | private readonly List _data = new()
12 | {
13 | //Ellipse
14 | new object[] { new Circle(0, 0, 10), Vector2.One, true },
15 | new object[] { new Circle(0, 0, 10), new Vector2(20, 20), false },
16 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(0, 0), true },
17 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(0, 1), true },
18 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(1, 1), false },
19 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(0, 1), true },
20 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(1, -1), false },
21 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(0, -1), true },
22 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(-1, -1), false },
23 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(-1, 0), true },
24 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(-1, 1), false },
25 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(0, 0), true },
26 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(0, 1), true },
27 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(1, 1), false },
28 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(0, 1), true },
29 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(1, -1), false },
30 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(0, -1), true },
31 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(-1, -1), false },
32 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(-1, 0), true },
33 | new object[] { new Circle(Vector2.Zero, 1), new Vector2(-1, 1), false },
34 | };
35 |
36 | public IEnumerator GetEnumerator()
37 | {
38 | return _data.GetEnumerator();
39 | }
40 |
41 | IEnumerator IEnumerable.GetEnumerator()
42 | {
43 | return GetEnumerator();
44 | }
45 | }
--------------------------------------------------------------------------------
/Tests/Collision/PointCollisionTestData/PointVector2CollisionTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Collision.PointCollisionTestData;
7 |
8 | public class PointVector2CollisionTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | //Point
13 | new object[] { new Point(0, 0), new Vector2(0, 0), true },
14 | new object[] { new Point(0, 0), new Vector2(0, 1), false },
15 | new object[] { new Point(0, 0), new Vector2(1, 0), false },
16 | new object[] { new Point(0, 0), new Vector2(1, 1), false }
17 | };
18 |
19 | public IEnumerator GetEnumerator()
20 | {
21 | return _data.GetEnumerator();
22 | }
23 |
24 | IEnumerator IEnumerable.GetEnumerator()
25 | {
26 | return GetEnumerator();
27 | }
28 | }
--------------------------------------------------------------------------------
/Tests/Collision/PointCollisionTestData/PolygonVector2CollisionTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Collision.PointCollisionTestData;
7 |
8 | public class PolygonVector2CollisionTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | //Polygon
13 | new object[] { Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One), Vector2.Zero, true },
14 | new object[] { Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One), new Vector2(2, 2), false },
15 | new object[] { Polygon.Rectangle.FromTwoPoints(new Vector2(10, 10), new Vector2(20, 20)), Vector2.Zero, false },
16 | new object[]
17 | { new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), Vector2.Zero, false },
18 | new object[]
19 | {
20 | new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), new Vector2(14, 15), false
21 | },
22 | new object[]
23 | {
24 | new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), new Vector2(15, 15), true
25 | },
26 | new object[]
27 | {
28 | new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), new Vector2(16, 15), true
29 | },
30 | new object[]
31 | {
32 | new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), new Vector2(19, 15), true
33 | },
34 | new object[]
35 | {
36 | new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), new Vector2(20, 15), true
37 | },
38 | new object[]
39 | {
40 | new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), new Vector2(21, 15), false
41 | },
42 | new object[]
43 | {
44 | new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), new Vector2(15, 9), false
45 | },
46 | new object[]
47 | {
48 | new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), new Vector2(15, 10), true
49 | },
50 | new object[]
51 | { new Polygon(new Vector2(10, 10), new Vector2(20, 20), new Vector2(20, 10)), new Vector2(15, 11), true }
52 | };
53 |
54 | public IEnumerator GetEnumerator()
55 | {
56 | return _data.GetEnumerator();
57 | }
58 |
59 | IEnumerator IEnumerable.GetEnumerator()
60 | {
61 | return GetEnumerator();
62 | }
63 | }
--------------------------------------------------------------------------------
/Tests/Collision/PointCollisionTestData/PolylineVector2CollisionTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Collision.PointCollisionTestData;
7 |
8 | public class PolylineVector2CollisionTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | //PolyLine
13 | new object[] { new PolyLine(0, 0, 10, 10), new Vector2(-1, -1), false },
14 | new object[] { new PolyLine(0, 0, 10, 10), new Vector2(0, -1), false },
15 | new object[] { new PolyLine(0, 0, 10, 10), new Vector2(-1, 0), false },
16 | new object[] { new PolyLine(0, 0, 10, 10), new Vector2(0, 0), true },
17 | new object[] { new PolyLine(0, 0, 10, 10), new Vector2(5, 5), true },
18 | new object[] { new PolyLine(0, 0, 10, 10), new Vector2(10, 10), true },
19 | new object[] { new PolyLine(0, 0, 10, 10), new Vector2(11, 11), false },
20 | new object[] { new PolyLine(0, 0, 10, 10), new Vector2(10, 11), false },
21 | new object[] { new PolyLine(0, 0, 10, 10), new Vector2(11, 10), false },
22 | new object[] { new PolyLine(0, 10, 10, 0, 0, -10, -10, 0), Vector2.Zero, false },
23 | new object[] { new PolyLine(0, 10, 10, 0, 0, -10, -10, 0), Vector2.One, false }
24 | };
25 |
26 | public IEnumerator GetEnumerator()
27 | {
28 | return _data.GetEnumerator();
29 | }
30 |
31 | IEnumerator IEnumerable.GetEnumerator()
32 | {
33 | return GetEnumerator();
34 | }
35 | }
--------------------------------------------------------------------------------
/Tests/Collision/PrimitiveCollisionTestData/EllipsePrimitiveCollisionTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections;
3 | using System.Collections.Generic;
4 | using System.Numerics;
5 | using Aptacode.Geometry.Primitives;
6 |
7 | namespace Aptacode.Geometry.Tests.Collision.PrimitiveCollisionTestData;
8 |
9 | public class EllipsePrimitiveCollisionTestDataGenerator : IEnumerable
10 | {
11 | private readonly List _data = new()
12 | {
13 | //Ellipse Ellipse
14 | new object[]
15 | { new Circle(10, 10, 10), new Circle(20, 20, 10), true }, //circle intersection
16 | new object[]
17 | { new Circle(10, 10, 10), new Circle(10, 10, 5), true }, //circle containment
18 | new object[]
19 | {
20 | new Circle(Vector2.Zero, 1), new Circle(new Vector2(2, 2), 1), false
21 | },
22 | new object[] { new Circle(Vector2.Zero, 1), new Point(new Vector2(2, 2)), false },
23 | new object[]
24 | {
25 | new Circle(Vector2.Zero, 1), PolyLine.Create(new Vector2(2, 2), new Vector2(3, 3)),
26 | false
27 | },
28 |
29 | new object[]
30 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(10, 0), new Vector2(10, 20)), true },
31 | new object[]
32 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(9, 0), new Vector2(9, 20)), true },
33 | new object[]
34 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(11, 0), new Vector2(11, 20)), true },
35 | new object[]
36 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(8, 0), new Vector2(8, 20)), false },
37 | new object[]
38 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(12, 0), new Vector2(12, 20)), false },
39 | new object[]
40 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(0, 10), new Vector2(20, 10)), true },
41 | new object[]
42 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(0, 9), new Vector2(20, 9)), true },
43 | new object[]
44 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(0, 11), new Vector2(20, 11)), true },
45 | new object[]
46 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(0, 8), new Vector2(20, 8)), false },
47 | new object[]
48 | { new Circle(new Vector2(10), 1), PolyLine.Create(new Vector2(0, 12), new Vector2(20, 12)), false },
49 | new object[]
50 | {
51 | new Circle(Vector2.Zero, 1),
52 | Polygon.Rectangle.FromTwoPoints(new Vector2(2, 2), Vector2.One), false
53 | }
54 | };
55 |
56 | public IEnumerator GetEnumerator()
57 | {
58 | return _data.GetEnumerator();
59 | }
60 |
61 | IEnumerator IEnumerable.GetEnumerator()
62 | {
63 | return GetEnumerator();
64 | }
65 | }
--------------------------------------------------------------------------------
/Tests/Collision/PrimitiveCollisionTestData/PointPrimitiveCollisionTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections;
3 | using System.Collections.Generic;
4 | using System.Numerics;
5 | using Aptacode.Geometry.Primitives;
6 |
7 | namespace Aptacode.Geometry.Tests.Collision.PrimitiveCollisionTestData;
8 |
9 | public class PointPrimitiveCollisionTestDataGenerator : IEnumerable
10 | {
11 | private readonly List _data = new()
12 | {
13 | //Point Point
14 | new object[] { new Point(0, 0), new Point(0, 0), true },
15 | new object[] { new Point(0, 0), new Point(1, 1), false },
16 |
17 | //Ellipse Point
18 | new object[] { new Point(new Vector2(2, 2)), new Circle(Vector2.Zero,1), false }
19 | };
20 |
21 | public IEnumerator GetEnumerator()
22 | {
23 | return _data.GetEnumerator();
24 | }
25 |
26 | IEnumerator IEnumerable.GetEnumerator()
27 | {
28 | return GetEnumerator();
29 | }
30 | }
--------------------------------------------------------------------------------
/Tests/Collision/PrimitiveCollisionTestData/PolygonPrimitiveCollisionTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections;
3 | using System.Collections.Generic;
4 | using System.Numerics;
5 | using Aptacode.Geometry.Primitives;
6 |
7 | namespace Aptacode.Geometry.Tests.Collision.PrimitiveCollisionTestData;
8 |
9 | public class PolygonPrimitiveCollisionTestDataGenerator : IEnumerable
10 | {
11 | private readonly List _data = new()
12 | {
13 | //Circle Polygon
14 | new object[]
15 | {
16 | new Circle(Vector2.Zero, 1),
17 | Polygon.Rectangle.FromTwoPoints(new Vector2(2, 2), Vector2.One), false
18 | },
19 |
20 | //PolyLine Polygon
21 | new object[]
22 | {
23 | Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One),
24 | Polygon.Rectangle.FromTwoPoints(Vector2.One, new Vector2(2, 2)), true
25 | },
26 |
27 | //PolyLine Polygon
28 | new object[]
29 | {
30 | Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One),
31 | PolyLine.Create(Vector2.Zero, Vector2.One), true
32 | }
33 | };
34 |
35 | public IEnumerator GetEnumerator()
36 | {
37 | return _data.GetEnumerator();
38 | }
39 |
40 | IEnumerator IEnumerable.GetEnumerator()
41 | {
42 | return GetEnumerator();
43 | }
44 | }
--------------------------------------------------------------------------------
/Tests/Collision/PrimitiveCollisionTestData/PolylinePrimitiveCollisionTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Collision.PrimitiveCollisionTestData;
7 |
8 | public class PolylinePrimitiveCollisionTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | //Circle PolyLine
13 | new object[]
14 | {
15 | new Circle(Vector2.Zero, 1), PolyLine.Create(new Vector2(2, 2), new Vector2(3, 3)),
16 | false
17 | },
18 |
19 | //Polyline PolyLine
20 | new object[]
21 | { PolyLine.Create(Vector2.Zero, Vector2.One), PolyLine.Create(Vector2.One, new Vector2(2, 2)), true },
22 | new object[]
23 | {
24 | PolyLine.Create(Vector2.Zero, new Vector2(10, 10)),
25 | PolyLine.Create(new Vector2(10, 0), new Vector2(0, 10)), true
26 | },
27 | new object[]
28 | {
29 | PolyLine.Create(Vector2.Zero, Vector2.One), PolyLine.Create(new Vector2(2, 2), new Vector2(3, 3)), false
30 | }
31 | };
32 |
33 | public IEnumerator GetEnumerator()
34 | {
35 | return _data.GetEnumerator();
36 | }
37 |
38 | IEnumerator IEnumerable.GetEnumerator()
39 | {
40 | return GetEnumerator();
41 | }
42 | }
--------------------------------------------------------------------------------
/Tests/Logo.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Aptacode/Geometry/b61a409286a742fa6a8f705535e2ccb1842a6cf9/Tests/Logo.ico
--------------------------------------------------------------------------------
/Tests/Primitives/Creation/EllipseCreationTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | //using System.Collections;
2 | //using System.Collections.Generic;
3 | //using Aptacode.Geometry.Primitives;
4 |
5 | //namespace Aptacode.Geometry.Tests.Primitives.Creation;
6 |
7 | //public class EllipseCreationTestDataGenerator : IEnumerable
8 | //{
9 | // private readonly List _data = new()
10 | // {
11 | // //Ellipse
12 | // new object[] { Ellipse.Zero, Vertices.VertexArray.Create(0, 0) },
13 | // new object[] { Ellipse.Unit, Vertices.VertexArray.Create(0, 0) }
14 | // };
15 |
16 | // public IEnumerator GetEnumerator()
17 | // {
18 | // return _data.GetEnumerator();
19 | // }
20 |
21 | // IEnumerator IEnumerable.GetEnumerator()
22 | // {
23 | // return GetEnumerator();
24 | // }
25 | //}
--------------------------------------------------------------------------------
/Tests/Primitives/Creation/PointCreationTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | //using System.Collections;
2 | //using System.Collections.Generic;
3 | //using System.Numerics;
4 | //using Aptacode.Geometry.Primitives;
5 |
6 | //namespace Aptacode.Geometry.Tests.Primitives.Creation;
7 |
8 | //public class PointCreationTestDataGenerator : IEnumerable
9 | //{
10 | // private readonly List _data = new()
11 | // {
12 | // new object[] { Point.Zero, Vertices.VertexArray.Create(0, 0) },
13 | // new object[] { Point.Unit, Vertices.VertexArray.Create(1, 1) },
14 | // new object[] { Point.Create(0, 0), Vertices.VertexArray.Create(0, 0) },
15 | // new object[] { Point.Create(new Vector2(0, 0)), Vertices.VertexArray.Create(0, 0) }
16 | // };
17 |
18 | // public IEnumerator GetEnumerator()
19 | // {
20 | // return _data.GetEnumerator();
21 | // }
22 |
23 | // IEnumerator IEnumerable.GetEnumerator()
24 | // {
25 | // return GetEnumerator();
26 | // }
27 | //}
--------------------------------------------------------------------------------
/Tests/Primitives/Creation/PolygonCreationTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | //using System.Collections;
2 | //using System.Collections.Generic;
3 | //using System.Numerics;
4 | //using Aptacode.Geometry.Primitives;
5 |
6 | //namespace Aptacode.Geometry.Tests.Primitives.Creation;
7 |
8 | //public class PolygonCreationTestDataGenerator : IEnumerable
9 | //{
10 | // private readonly List _data = new()
11 | // {
12 | // new object[]
13 | // {
14 | // Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One),
15 | // Vertices.VertexArray.Create(0, 0, 0, 1, 1, 1, 1, 0)
16 | // },
17 | // new object[]
18 | // {
19 | // Polygon.Create(Vector2.Zero, Vector2.One, new Vector2(1, 0)), Vertices.VertexArray.Create(0, 0, 1, 1, 1, 0)
20 | // }
21 | // };
22 |
23 | // public IEnumerator GetEnumerator()
24 | // {
25 | // return _data.GetEnumerator();
26 | // }
27 |
28 | // IEnumerator IEnumerable.GetEnumerator()
29 | // {
30 | // return GetEnumerator();
31 | // }
32 | //}
--------------------------------------------------------------------------------
/Tests/Primitives/Creation/PolylineCreationTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | //using System.Collections;
2 | //using System.Collections.Generic;
3 | //using Aptacode.Geometry.Primitives;
4 |
5 | //namespace Aptacode.Geometry.Tests.Primitives.Creation;
6 |
7 | //public class PolylineCreationTestDataGenerator : IEnumerable
8 | //{
9 | // private readonly List _data = new()
10 | // {
11 | // new object[] { PolyLine.Zero, Vertices.VertexArray.Create(0, 0, 0, 0) },
12 | // new object[] { PolyLine.Create(0, 0, 1, 1, 2, 2), Vertices.VertexArray.Create(0, 0, 1, 1, 2, 2) }
13 | // };
14 |
15 | // public IEnumerator GetEnumerator()
16 | // {
17 | // return _data.GetEnumerator();
18 | // }
19 |
20 | // IEnumerator IEnumerable.GetEnumerator()
21 | // {
22 | // return GetEnumerator();
23 | // }
24 | //}
--------------------------------------------------------------------------------
/Tests/Primitives/Creation/PrimitiveCreationTests.cs:
--------------------------------------------------------------------------------
1 | using Aptacode.Geometry.Primitives;
2 | using System.Numerics;
3 | using Xunit;
4 |
5 | namespace Aptacode.Geometry.Tests.Primitives.Creation;
6 |
7 | public class PrimitiveCreationTests
8 | {
9 | //[Theory]
10 | //[ClassData(typeof(PointCreationTestDataGenerator))]
11 | //[ClassData(typeof(EllipseCreationTestDataGenerator))]
12 | //[ClassData(typeof(PolygonCreationTestDataGenerator))]
13 | //[ClassData(typeof(PolylineCreationTestDataGenerator))]
14 | //public void PrimitiveCreation(Primitive primitive, Vector2[] expected)
15 | //{
16 | // //Arrange
17 | // //Act
18 | // //Assert
19 | // Assert.Equal(expected, primitive.Vertices);
20 | //}
21 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Equality/EllipseEqualityTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using Aptacode.Geometry.Primitives;
4 |
5 | namespace Aptacode.Geometry.Tests.Primitives.Equality;
6 |
7 | public class EllipseEqualityTestDataGenerator : IEnumerable
8 | {
9 | private readonly List _data = new()
10 | {
11 | new object[] { new Circle(0, 0, 1), new Circle(0, 0, 1), true },
12 | new object[] { new Circle(0, 0, 1), new Circle(1, 1, 1), false },
13 | new object[] { new Circle(0, 0, 1), new Circle(0, 0, 2), false },
14 | };
15 |
16 | public IEnumerator GetEnumerator()
17 | {
18 | return _data.GetEnumerator();
19 | }
20 |
21 | IEnumerator IEnumerable.GetEnumerator()
22 | {
23 | return GetEnumerator();
24 | }
25 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Equality/PointEqualityTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Primitives.Equality;
7 |
8 | public class PointEqualityTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | new object[] { Point.Zero, Point.Zero, true },
13 | new object[] { Point.Unit, Point.Unit, true },
14 | new object[] { new Point(2, 2), new Point(2, 2), true },
15 | new object[] { Point.Unit, Point.Zero, false },
16 | new object[] { Point.Zero, Circle.Unit, false },
17 | new object[] { Point.Zero, Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One), false },
18 | new object[] { Point.Zero, PolyLine.Create(Vector2.Zero, Vector2.One), false },
19 | new object[] { Point.Zero, null, false },
20 | };
21 |
22 | public IEnumerator GetEnumerator()
23 | {
24 | return _data.GetEnumerator();
25 | }
26 |
27 | IEnumerator IEnumerable.GetEnumerator()
28 | {
29 | return GetEnumerator();
30 | }
31 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Equality/PolygonEqualityTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using Aptacode.Geometry.Primitives;
4 |
5 | namespace Aptacode.Geometry.Tests.Primitives.Equality;
6 |
7 | public class PolygonEqualityTestDataGenerator : IEnumerable
8 | {
9 | private readonly List _data = new()
10 | {
11 | new object[] { new Polygon(0, 0, 1, 1, 0, 1), new Polygon(0, 0, 1, 1, 0, 1), true },
12 | new object[] { new Polygon(0, 0, 1, 1, 0, 1), new Polygon(0, 0, 1, 1, 0, 2), false },
13 | new object[] { new Polygon(0, 0, 1, 1, 0, 1), new Polygon(0, 0, 1, 1, 0, 1, 0, 2), false },
14 | new object[] { new Polygon(0, 0, 1, 1, 0, 1), null, false },
15 | };
16 |
17 | public IEnumerator GetEnumerator()
18 | {
19 | return _data.GetEnumerator();
20 | }
21 |
22 | IEnumerator IEnumerable.GetEnumerator()
23 | {
24 | return GetEnumerator();
25 | }
26 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Equality/PolylineEqualityTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using Aptacode.Geometry.Primitives;
4 |
5 | namespace Aptacode.Geometry.Tests.Primitives.Equality;
6 |
7 | public class PolylineEqualityTestDataGenerator : IEnumerable
8 | {
9 | private readonly List _data = new()
10 | {
11 | new object[] { new PolyLine(0, 0, 1, 1), new PolyLine(0, 0, 1, 1), true },
12 | new object[] { new PolyLine(0, 0, 1, 1), new PolyLine(0, 0, 1, 0), false },
13 | new object[] { new PolyLine(0, 0, 1, 1), new PolyLine(0, 0, 1, 1, 2, 2), false },
14 | new object[] { new PolyLine(0, 0, 1, 1), null, false },
15 | };
16 |
17 | public IEnumerator GetEnumerator()
18 | {
19 | return _data.GetEnumerator();
20 | }
21 |
22 | IEnumerator IEnumerable.GetEnumerator()
23 | {
24 | return GetEnumerator();
25 | }
26 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Equality/PrimitiveEqualityTests.cs:
--------------------------------------------------------------------------------
1 | using Aptacode.Geometry.Primitives;
2 | using Xunit;
3 |
4 | namespace Aptacode.Geometry.Tests.Primitives.Equality;
5 |
6 | public class PrimitiveEqualityTests
7 | {
8 | [Theory]
9 | [ClassData(typeof(PointEqualityTestDataGenerator))]
10 | [ClassData(typeof(EllipseEqualityTestDataGenerator))]
11 | [ClassData(typeof(PolygonEqualityTestDataGenerator))]
12 | [ClassData(typeof(PolylineEqualityTestDataGenerator))]
13 | public void Primitive_Equality(Primitive p1, Primitive p2, bool areEqual)
14 | {
15 | //Arrange
16 | //Act
17 |
18 | //Assert
19 | if (p1 != null)
20 | {
21 | var equalsMethodResult = p1.AreEqual(p2);
22 | Assert.Equal(areEqual, equalsMethodResult);
23 | }
24 | else
25 | {
26 | var equalsMethodResult = p2.AreEqual(p1);
27 | Assert.Equal(areEqual, equalsMethodResult);
28 | }
29 | }
30 | }
--------------------------------------------------------------------------------
/Tests/Primitives/ToString/EllipseToStringTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using Aptacode.Geometry.Primitives;
4 |
5 | namespace Aptacode.Geometry.Tests.Primitives.ToString;
6 |
7 | public class EllipseToStringTestDataGenerator : IEnumerable
8 | {
9 | private readonly List _data = new()
10 | {
11 | new object[] { new Circle(0, 0, 1), "Circle (0,0), 1" }
12 | };
13 |
14 | public IEnumerator GetEnumerator()
15 | {
16 | return _data.GetEnumerator();
17 | }
18 |
19 | IEnumerator IEnumerable.GetEnumerator()
20 | {
21 | return GetEnumerator();
22 | }
23 | }
--------------------------------------------------------------------------------
/Tests/Primitives/ToString/PointToStringTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using Aptacode.Geometry.Primitives;
4 |
5 | namespace Aptacode.Geometry.Tests.Primitives.ToString;
6 |
7 | public class PointToStringTestDataGenerator : IEnumerable
8 | {
9 | private readonly List _data = new()
10 | {
11 | new object[] { Point.Zero, "Point (0,0)" },
12 | new object[] { Point.Unit, "Point (1,1)" },
13 | new object[] { new Point(3, 5), "Point (3,5)" }
14 | };
15 |
16 | public IEnumerator GetEnumerator()
17 | {
18 | return _data.GetEnumerator();
19 | }
20 |
21 | IEnumerator IEnumerable.GetEnumerator()
22 | {
23 | return GetEnumerator();
24 | }
25 | }
--------------------------------------------------------------------------------
/Tests/Primitives/ToString/PolygonToStringTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using Aptacode.Geometry.Primitives;
4 |
5 | namespace Aptacode.Geometry.Tests.Primitives.ToString;
6 |
7 | public class PolygonToStringTestDataGenerator : IEnumerable
8 | {
9 | private readonly List _data = new()
10 | {
11 | new object[] { new Polygon(0, 0, 1, 1, 0, 1), "Polygon (0,0), (1,1), (0,1)" }
12 | };
13 |
14 | public IEnumerator GetEnumerator()
15 | {
16 | return _data.GetEnumerator();
17 | }
18 |
19 | IEnumerator IEnumerable.GetEnumerator()
20 | {
21 | return GetEnumerator();
22 | }
23 | }
--------------------------------------------------------------------------------
/Tests/Primitives/ToString/PolylineToStringTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using Aptacode.Geometry.Primitives;
4 |
5 | namespace Aptacode.Geometry.Tests.Primitives.ToString;
6 |
7 | public class PolylineToStringTestDataGenerator : IEnumerable
8 | {
9 | private readonly List _data = new()
10 | {
11 | new object[] { PolyLine.Zero, "PolyLine (0,0), (0,0)" },
12 | new object[] { new PolyLine(0, 0, 1, 1), "PolyLine (0,0), (1,1)" }
13 | };
14 |
15 | public IEnumerator GetEnumerator()
16 | {
17 | return _data.GetEnumerator();
18 | }
19 |
20 | IEnumerator IEnumerable.GetEnumerator()
21 | {
22 | return GetEnumerator();
23 | }
24 | }
--------------------------------------------------------------------------------
/Tests/Primitives/ToString/PrimitiveToStringTests.cs:
--------------------------------------------------------------------------------
1 | using Aptacode.Geometry.Primitives;
2 | using Xunit;
3 |
4 | namespace Aptacode.Geometry.Tests.Primitives.ToString;
5 |
6 | public class PrimitiveToStringTests
7 | {
8 | [Theory]
9 | [ClassData(typeof(PointToStringTestDataGenerator))]
10 | [ClassData(typeof(EllipseToStringTestDataGenerator))]
11 | [ClassData(typeof(PolygonToStringTestDataGenerator))]
12 | [ClassData(typeof(PolylineToStringTestDataGenerator))]
13 | public void PrimitiveToStringTest(Primitive p1, string expected)
14 | {
15 | //Arrange
16 | //Act
17 | var toString = p1.ToString();
18 |
19 | //Assert
20 | Assert.Equal(expected, toString);
21 | }
22 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Transformation/PrimitiveTransformationTests.cs:
--------------------------------------------------------------------------------
1 | using System.Numerics;
2 | using Aptacode.Geometry.Primitives;
3 | using Aptacode.Geometry.Tests.Primitives.Transformation.Scale;
4 | using Aptacode.Geometry.Tests.Primitives.Transformation.Translate;
5 | using Xunit;
6 | using Xunit.Abstractions;
7 |
8 | namespace Aptacode.Geometry.Tests.Primitives.Transformation;
9 |
10 | public class PrimitiveTransformationTests
11 | {
12 | private readonly ITestOutputHelper testOutput;
13 |
14 | public PrimitiveTransformationTests(ITestOutputHelper testOutput)
15 | {
16 | this.testOutput = testOutput;
17 | }
18 | [Theory]
19 | [ClassData(typeof(PointTranslationTestDataGenerator))]
20 | [ClassData(typeof(EllipseTranslationTestDataGenerator))]
21 | [ClassData(typeof(PolygonTranslationTestDataGenerator))]
22 | [ClassData(typeof(PolylineTranslationTestDataGenerator))]
23 | public void Primitive_Translation(Primitive p1, Vector2 delta, Primitive expected)
24 | {
25 | //Arrange
26 | testOutput.WriteLine($"{p1} + ({delta.X},{delta.Y}) => {expected}");
27 |
28 | //Act
29 | p1.Translate(delta);
30 |
31 | //Assert
32 | Assert.True(expected.AreEqual(p1));
33 | }
34 |
35 | [Theory]
36 | [ClassData(typeof(PointCenterScaleTestDataGenerator))]
37 | [ClassData(typeof(EllipseCenterScaleTestDataGenerator))]
38 | [ClassData(typeof(PolygonCenterScaleTestDataGenerator))]
39 | [ClassData(typeof(PolylineCenterScaleTestDataGenerator))]
40 | public void Primitive_CenterScale(Primitive p1, Vector2 delta, Primitive expected)
41 | {
42 | //Arrange
43 | testOutput.WriteLine($"{p1} + ({delta.X},{delta.Y}) => {expected}");
44 |
45 | //Act
46 | var actual = p1.ScaleAboutCenter(delta);
47 |
48 | testOutput.WriteLine($"Actual: {actual}");
49 |
50 | //Assert
51 | Assert.True(expected.AreEqual(p1));
52 | }
53 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Transformation/Scale/EllipseCenterScaleTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Primitives.Transformation.Scale;
7 |
8 | public class EllipseCenterScaleTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | new object[] { new Circle(Vector2.Zero, 1), Vector2.One, new Circle(Vector2.Zero, 1) },
13 | };
14 |
15 | public IEnumerator GetEnumerator()
16 | {
17 | return _data.GetEnumerator();
18 | }
19 |
20 | IEnumerator IEnumerable.GetEnumerator()
21 | {
22 | return GetEnumerator();
23 | }
24 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Transformation/Scale/PointCenterScaleTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Primitives.Transformation.Scale;
7 |
8 | public class PointCenterScaleTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | new object[] { Point.Zero, Vector2.Zero, Point.Zero },
13 | new object[] { Point.Zero, Vector2.One, Point.Zero },
14 | new object[] { Point.Zero, new Vector2(2), Point.Zero }
15 | };
16 |
17 | public IEnumerator GetEnumerator()
18 | {
19 | return _data.GetEnumerator();
20 | }
21 |
22 | IEnumerator IEnumerable.GetEnumerator()
23 | {
24 | return GetEnumerator();
25 | }
26 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Transformation/Scale/PolygonCenterScaleTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Primitives.Transformation.Scale;
7 |
8 | public class PolygonCenterScaleTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | new object[]
13 | {
14 | Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One),
15 | Vector2.One,
16 | Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One)
17 | },
18 | new object[]
19 | {
20 | Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One),
21 | new Vector2(2),
22 | Polygon.Rectangle.FromTwoPoints(new Vector2(-0.5f, -0.5f), new Vector2(1.5f, 1.5f))
23 | }
24 | };
25 |
26 | public IEnumerator GetEnumerator()
27 | {
28 | return _data.GetEnumerator();
29 | }
30 |
31 | IEnumerator IEnumerable.GetEnumerator()
32 | {
33 | return GetEnumerator();
34 | }
35 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Transformation/Scale/PolylineCenterScaleTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Primitives.Transformation.Scale;
7 |
8 | public class PolylineCenterScaleTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | new object[]
13 | {
14 | PolyLine.Create(Vector2.Zero, Vector2.One),
15 | Vector2.One,
16 | PolyLine.Create(Vector2.Zero, Vector2.One)
17 | },
18 | new object[]
19 | {
20 | PolyLine.Create(Vector2.Zero, Vector2.One),
21 | new Vector2(2),
22 | PolyLine.Create(new Vector2(-0.5f, -0.5f), new Vector2(1.5f, 1.5f))
23 | }
24 | };
25 |
26 | public IEnumerator GetEnumerator()
27 | {
28 | return _data.GetEnumerator();
29 | }
30 |
31 | IEnumerator IEnumerable.GetEnumerator()
32 | {
33 | return GetEnumerator();
34 | }
35 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Transformation/Translate/EllipseTranslationTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Primitives.Transformation.Translate;
7 |
8 | public class EllipseTranslationTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | new object[] { new Circle(Vector2.Zero, 1), Vector2.One, new Circle(Vector2.One, 1) },
13 | new object[] { new Circle(Vector2.Zero, 1), Vector2.Zero, new Circle(Vector2.Zero, 1) }
14 | };
15 |
16 | public IEnumerator GetEnumerator()
17 | {
18 | return _data.GetEnumerator();
19 | }
20 |
21 | IEnumerator IEnumerable.GetEnumerator()
22 | {
23 | return GetEnumerator();
24 | }
25 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Transformation/Translate/PointTranslationTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Primitives.Transformation.Translate;
7 |
8 | public class PointTranslationTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | new object[] { Point.Zero, Vector2.One, Point.Unit },
13 | new object[] { Point.Zero, Vector2.Zero, Point.Zero }
14 | };
15 |
16 | public IEnumerator GetEnumerator()
17 | {
18 | return _data.GetEnumerator();
19 | }
20 |
21 | IEnumerator IEnumerable.GetEnumerator()
22 | {
23 | return GetEnumerator();
24 | }
25 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Transformation/Translate/PolygonTranslationTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Primitives.Transformation.Translate;
7 |
8 | public class PolygonTranslationTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | new object[]
13 | {
14 | Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One), Vector2.One,
15 | Polygon.Rectangle.FromTwoPoints(Vector2.One, new Vector2(2, 2))
16 | },
17 | new object[]
18 | {
19 | Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One), Vector2.Zero,
20 | Polygon.Rectangle.FromTwoPoints(Vector2.Zero, Vector2.One)
21 | }
22 | };
23 |
24 | public IEnumerator GetEnumerator()
25 | {
26 | return _data.GetEnumerator();
27 | }
28 |
29 | IEnumerator IEnumerable.GetEnumerator()
30 | {
31 | return GetEnumerator();
32 | }
33 | }
--------------------------------------------------------------------------------
/Tests/Primitives/Transformation/Translate/PolylineTranslationTestDataGenerator.cs:
--------------------------------------------------------------------------------
1 | using System.Collections;
2 | using System.Collections.Generic;
3 | using System.Numerics;
4 | using Aptacode.Geometry.Primitives;
5 |
6 | namespace Aptacode.Geometry.Tests.Primitives.Transformation.Translate;
7 |
8 | public class PolylineTranslationTestDataGenerator : IEnumerable
9 | {
10 | private readonly List _data = new()
11 | {
12 | new object[]
13 | {
14 | PolyLine.Create(Vector2.Zero, Vector2.One), Vector2.One, PolyLine.Create(Vector2.One, new Vector2(2, 2))
15 | },
16 | new object[]
17 | { PolyLine.Create(Vector2.Zero, Vector2.One), Vector2.Zero, PolyLine.Create(Vector2.Zero, Vector2.One) }
18 | };
19 |
20 | public IEnumerator GetEnumerator()
21 | {
22 | return _data.GetEnumerator();
23 | }
24 |
25 | IEnumerator IEnumerable.GetEnumerator()
26 | {
27 | return GetEnumerator();
28 | }
29 | }
--------------------------------------------------------------------------------
/Tests/Tests.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | net7.0
5 | false
6 | Logo.ico
7 | Aptacode.Geometry.Tests
8 | Aptacode.Geometry.Tests
9 |
10 |
11 |
12 |
16 | runtime; build; native; contentfiles; analyzers; buildtransitive
17 | all
18 |
19 |
20 | runtime; build; native; contentfiles; analyzers; buildtransitive
21 | all
22 |
23 |
24 |
25 |
26 |
28 |
29 |
30 |
35 |
36 |
--------------------------------------------------------------------------------
/Tests/UnitTests.cs:
--------------------------------------------------------------------------------
1 | using System.Numerics;
2 | using Aptacode.Geometry.Collision;
3 | using Aptacode.Geometry.Primitives;
4 | using Aptacode.Geometry.Utilities;
5 | using Xunit;
6 |
7 | namespace Aptacode.Geometry.Tests;
8 |
9 | public class UnitTests
10 | {
11 | [Fact]
12 | public void Perp_Test()
13 | {
14 | var a = new Vector2(6, 12);
15 | var b = a.Perp();
16 |
17 | Assert.Equal(new Vector2(12, -6), b);
18 | }
19 |
20 | [Fact]
21 | public void PerpDotXVectorCrossTest()
22 | {
23 | var a = new Vector2(6, 12);
24 | var b = new Vector2(12, 6);
25 |
26 | var perpDot = a.PerpDot(b);
27 | var cross = a.VectorCross(b);
28 |
29 | Assert.True(perpDot == -cross);
30 | }
31 |
32 | [Fact]
33 | public void newLineSegmentIntersection_Test()
34 | {
35 | var A1 = new Vector2(10, 10);
36 | var A2 = new Vector2(20, 10);
37 |
38 | var B1 = new Vector2(15, 10);
39 | var B2 = new Vector2(15, 15);
40 |
41 | Assert.True((A1, A2).Intersects((B1, B2)));
42 | }
43 | }
--------------------------------------------------------------------------------
/development-azure-pipelines.yml:
--------------------------------------------------------------------------------
1 | # Starter pipeline
2 | # Start with a minimal pipeline that you can customize to build and deploy your code.
3 | # Add steps that build, run tests, deploy, and more:
4 | # https://aka.ms/yaml
5 |
6 | trigger:
7 | - Development
8 |
9 | pool:
10 | vmImage: 'windows-latest'
11 |
12 | variables:
13 | solution: '**/*.sln'
14 | buildPlatform: 'Any CPU'
15 | buildConfiguration: 'Release'
16 | project: '**/Geometry.csproj'
17 | NUGET_PACKAGES: $(Pipeline.Workspace)/.nuget/packages
18 | steps:
19 |
20 | - task: UseDotNet@2
21 | displayName: 'Use .NET 5'
22 | inputs:
23 | version: 5.x
24 |
25 | - task: DotNetCoreCLI@2
26 | displayName: 'Build'
27 | inputs:
28 | command: 'build'
29 | arguments: '--configuration $(buildConfiguration)'
30 | projects: '$(project)'
31 |
32 | - task: DotNetCoreCLI@2
33 | displayName: "Pack"
34 | inputs:
35 | command: 'pack'
36 | arguments: '--configuration $(buildConfiguration)'
37 | packagesToPack: '$(project)'
38 | nobuild: true
39 | versioningScheme: 'byPrereleaseNumber'
40 | majorVersion: '1'
41 | minorVersion: '0'
42 | patchVersion: '6'
43 |
44 | - task: NuGetCommand@2
45 | displayName: 'Push'
46 | inputs:
47 | command: 'push'
48 | packagesToPush: '$(Build.ArtifactStagingDirectory)/**/*.nupkg;!$(Build.ArtifactStagingDirectory)/**/*.symbols.nupkg'
49 | nuGetFeedType: 'external'
50 | publishFeedCredentials: 'Nuget.org'
51 | allowPackageConflicts: true
--------------------------------------------------------------------------------
/production-azure-pipelines.yml:
--------------------------------------------------------------------------------
1 | # Starter pipeline
2 | # Start with a minimal pipeline that you can customize to build and deploy your code.
3 | # Add steps that build, run tests, deploy, and more:
4 | # https://aka.ms/yaml
5 |
6 | trigger:
7 | - Production
8 |
9 | pool:
10 | vmImage: 'windows-latest'
11 |
12 | variables:
13 | solution: '**/*.sln'
14 | buildPlatform: 'Any CPU'
15 | buildConfiguration: 'Release'
16 | project: '**/Geometry.csproj'
17 | NUGET_PACKAGES: $(Pipeline.Workspace)/.nuget/packages
18 | steps:
19 |
20 | - task: UseDotNet@2
21 | displayName: 'Use .NET 5'
22 | inputs:
23 | version: 5.x
24 |
25 | - task: DotNetCoreCLI@2
26 | displayName: 'Build'
27 | inputs:
28 | command: 'build'
29 | arguments: '--configuration $(buildConfiguration)'
30 | projects: '$(project)'
31 |
32 | - task: DotNetCoreCLI@2
33 | displayName: "Pack"
34 | inputs:
35 | command: 'pack'
36 | arguments: '--configuration $(buildConfiguration)'
37 | packagesToPack: '$(project)'
38 | nobuild: true
39 |
40 | - task: NuGetCommand@2
41 | displayName: 'Push'
42 | inputs:
43 | command: 'push'
44 | packagesToPush: '$(Build.ArtifactStagingDirectory)/**/*.nupkg;!$(Build.ArtifactStagingDirectory)/**/*.symbols.nupkg'
45 | nuGetFeedType: 'external'
46 | publishFeedCredentials: 'Nuget.org'
47 | allowPackageConflicts: true
--------------------------------------------------------------------------------
30 | ```
31 |
32 | #### Using Open Iconic's SVG Sprite
33 |
34 | Open Iconic also comes in a SVG sprite which allows you to display all the icons in the set with a single request. It's like an icon font, without being a hack.
35 |
36 | Adding an icon from an SVG sprite is a little different than what you're used to, but it's still a piece of cake. *Tip: To make your icons easily style able, we suggest adding a general class to the* `