me/Tetrahedrons
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removed 3d code

Browse Source
This commit is contained in:
David Allemang
2018-04-03 23:47:03 -04:00
parent 8bec0d6b80
commit ac5cd8dd1d
4 changed files with 39 additions and 526 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
Tetrahedrons/MVec3d.cs
View File

@@ -1,195 +0,0 @@
using System;
using OpenTK;
namespace Tetrahedrons
{
public struct MVec3D
{
public static readonly MVec3D Zero = new MVec3D(0, 0, 0, 0, 0, 0, 0, 0);
public static readonly MVec3D One = new MVec3D(1, 1, 1, 1, 1, 1, 1, 1);
public static readonly MVec3D Unit = new MVec3D(1, 0, 0, 0, 0, 0, 0, 0);
public static readonly MVec3D Unit1 = new MVec3D(0, 1, 0, 0, 0, 0, 0, 0);
public static readonly MVec3D Unit2 = new MVec3D(0, 0, 1, 0, 0, 0, 0, 0);
public static readonly MVec3D Unit3 = new MVec3D(0, 0, 0, 1, 0, 0, 0, 0);
public static readonly MVec3D Unit23 = new MVec3D(0, 0, 0, 0, 1, 0, 0, 0);
public static readonly MVec3D Unit31 = new MVec3D(0, 0, 0, 0, 0, 1, 0, 0);
public static readonly MVec3D Unit12 = new MVec3D(0, 0, 0, 0, 0, 0, 1, 0);
public static readonly MVec3D Unit123 = new MVec3D(0, 0, 0, 0, 0, 0, 0, 1);
public double E;
public double E1;
public double E2;
public double E3;
public double E23;
public double E31;
public double E12;
public double E123;
public MVec3D(double e, double e1, double e2, double e3, double e23, double e31, double e12, double e123)
{
E = e;
E1 = e1;
E2 = e2;
E3 = e3;
E23 = e23;
E31 = e31;
E12 = e12;
E123 = e123;
}
public MVec3D(MVec3D s, MVec3D v, MVec3D b, MVec3D t)
: this(s.E, v.E1, v.E2, v.E3, b.E23, b.E31, b.E12, t.E123)
{
}
public static MVec3D Scalar(double e)
{
return new MVec3D(e, 0, 0, 0, 0, 0, 0, 0);
}
public static MVec3D Vector(double e1, double e2, double e3)
{
return new MVec3D(0, e1, e2, e3, 0, 0, 0, 0);
}
public static MVec3D Vector(Vector3d v)
{
return new MVec3D(0, v.X, v.Y, v.Z, 0, 0, 0, 0);
}
public static MVec3D Bivector(double e23, double e31, double e12)
{
return new MVec3D(0, 0, 0, 0, e23, e31, e12, 0);
}
public static MVec3D Trivector(double e123)
{
return new MVec3D(0, 0, 0, 0, 0, 0, 0, e123);
}
public static MVec3D Rotor(double angle, MVec3D plane)
{
return Math.Cos(angle) + Math.Sin(angle) * plane;
}
public static MVec3D Add(MVec3D m, MVec3D n)
{
return new MVec3D(m.E + n.E,
m.E1 + n.E1, m.E2 + n.E2, m.E3 + n.E3,
m.E23 + n.E23, m.E31 + n.E31, m.E12 + n.E12,
m.E123 + n.E123);
}
public static MVec3D Sub(MVec3D m, MVec3D n)
{
return new MVec3D(m.E - n.E,
m.E1 - n.E1, m.E2 - n.E2, m.E3 - n.E3,
m.E23 - n.E23, m.E31 - n.E31, m.E12 - n.E12,
m.E123 - n.E123);
}
public static MVec3D Mult(MVec3D m, MVec3D n)
{
return new MVec3D(
m.E * n.E + m.E1 * n.E1 + m.E2 * n.E2 + m.E3 * n.E3 - m.E23 * n.E23 - m.E31 * n.E31 - m.E12 * n.E12 - m.E123 * n.E123,
m.E * n.E1 + m.E1 * n.E - m.E2 * n.E12 + m.E3 * n.E31 - m.E23 * n.E123 - m.E31 * n.E3 + m.E12 * n.E2 - m.E123 * n.E23,
m.E * n.E2 + m.E1 * n.E12 + m.E2 * n.E - m.E3 * n.E23 + m.E23 * n.E3 - m.E31 * n.E123 - m.E12 * n.E1 - m.E123 * n.E31,
m.E * n.E3 - m.E1 * n.E31 + m.E2 * n.E23 + m.E3 * n.E - m.E23 * n.E2 + m.E31 * n.E1 - m.E12 * n.E123 - m.E123 * n.E12,
m.E * n.E23 + m.E1 * n.E123 + m.E2 * n.E3 - m.E3 * n.E2 + m.E23 * n.E - m.E31 * n.E12 + m.E12 * n.E31 + m.E123 * n.E1,
m.E * n.E31 - m.E1 * n.E3 + m.E2 * n.E123 + m.E3 * n.E1 + m.E23 * n.E12 + m.E31 * n.E - m.E12 * n.E23 + m.E123 * n.E2,
m.E * n.E12 + m.E1 * n.E2 - m.E2 * n.E1 + m.E3 * n.E123 - m.E23 * n.E31 + m.E31 * n.E23 + m.E12 * n.E + m.E123 * n.E3,
m.E * n.E123 + m.E1 * n.E23 + m.E2 * n.E31 + m.E3 * n.E12 + m.E23 * n.E1 + m.E31 * n.E2 + m.E12 * n.E3 + m.E123 * n.E
);
}
public double Norm2 => E * E + E1 * E1 + E2 * E2 + E3 * E3 + E23 * E23 + E31 * E31 + E12 * E12 + E123 * E123;
public double Norm => Math.Sqrt(Norm2);
public MVec3D Inv
{
get
{
var n2 = Norm2;
return new MVec3D(E / n2, -E1 / n2, -E2 / n2, -E3 / n2, -E23 / n2, -E31 / n2, -E12 / n2, E123 / n2);
}
}
public MVec3D Grade(int k)
{
switch (k)
{
case 0:
return Scalar(E);
case 1:
return Vector(E1, E2, E3);
case 2:
return Bivector(E23, E31, E12);
case 3:
return Trivector(E123);
default:
return new MVec3D();
}
}
public static MVec3D Inner(MVec3D m, MVec3D n)
{
var m0 = m.Grade(0);
var m1 = m.Grade(1);
var m2 = m.Grade(2);
var m3 = m.Grade(3);
var n0 = n.Grade(0);
var n1 = n.Grade(1);
var n2 = n.Grade(2);
var n3 = n.Grade(3);
return new MVec3D(
m0 * n0 + m1 * n1 + m2 * n2 + m3 * n3,
m0 * n1 + m1 * n2 + m2 * n3,
m0 * n2 + m1 * n3,
m0 * n3
);
}
public static MVec3D Outer(MVec3D m, MVec3D n)
{
var m0 = m.Grade(0);
var m1 = m.Grade(1);
var m2 = m.Grade(2);
var m3 = m.Grade(3);
var n0 = n.Grade(0);
var n1 = n.Grade(1);
var n2 = n.Grade(2);
var n3 = n.Grade(3);
return new MVec3D(
m0 * n0,
m1 * n0 + m0 * n1,
m2 * n0 + m1 * n1 + m0 * n2,
m3 * n0 + m2 * n1 + m1 * n2 + m0 * m3
);
}
public static MVec3D operator ~(MVec3D m) => m.Inv;
public static MVec3D operator *(MVec3D m, MVec3D n) => Mult(m, n);
public static MVec3D operator +(MVec3D m, MVec3D n) => Add(m, n);
public static MVec3D operator -(MVec3D m, MVec3D n) => Sub(m, n);
public static MVec3D operator &(MVec3D m, MVec3D n) => Inner(m, n);
public static MVec3D operator ^(MVec3D m, MVec3D n) => Outer(m, n);
public Vector3d VectorPart => new Vector3d(E1, E2, E3);
public static implicit operator MVec3D(Vector3 v) => new MVec3D(0, v.X, v.Y, v.Z, 0, 0, 0, 0);
public static implicit operator MVec3D(Vector3d v) => new MVec3D(0, v.X, v.Y, v.Z, 0, 0, 0, 0);
public static implicit operator MVec3D(double s) => new MVec3D(s, 0, 0, 0, 0, 0, 0, 0);
public override string ToString()
{
return $"({E:0.00} {E1:0.00}e1 {E2:0.00}e2 {E3:0.00}e3 {E23:0.00}e23 {E31:0.00}e31 {E12:0.00}e12 {E123:0.00}e123)";
}
}
}

16
Tetrahedrons/Program.cs
View File

@@ -5,24 +5,10 @@ namespace Tetrahedrons
{
internal class Program : GameWindow
{
public static void NotMain(string[] args)
public static void Main(string[] args)
{
using (var p = new TetrahedronWindow())
p.Run();
}
public static void Main(string[] args)
{
var m = new MVec4D(0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0);
var i = m.Inv ?? MVec4D.Zero;
Console.Out.WriteLine("m = {0}", m);
Console.Out.WriteLine("m.Rev = {0}", m.Rev);
Console.Out.WriteLine("MVec4D.Mul(m, m.Rev) = {0}", MVec4D.Mul(m, m.Rev));
Console.Out.WriteLine("m.Inv = {0}", i);
Console.Out.WriteLine("MVec4D.Mul(m, m.Inv) = {0}", MVec4D.Mul(m, i));
Console.Out.WriteLine("MVec4D.Mul(m.Inv, m) = {0}", MVec4D.Mul(i, m));
}
}
}

353
Tetrahedrons/TetrahedronWindow.cs
View File

@@ -10,332 +10,55 @@ using OpenTK.Input;
namespace Tetrahedrons
{
public struct Polygon
{
public Vector3d[] Points;
public Color Color;
public class TetrahedronWindow : GameWindow
{
private Matrix4 _proj3d;
private Matrix4 _view;
public Polygon(Vector3d[] points) : this(points, Color.DodgerBlue)
{
}
Vector3d a = Vector3d.UnitX;
Vector3d b = Vector3d.UnitY;
public Polygon(Vector3d[] points, Color color)
{
Points = points;
Color = color;
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
public void Draw()
{
GL.Begin(PrimitiveType.TriangleStrip);
GL.Color3(Color);
foreach (var v in Points)
GL.Vertex3(v);
GL.End();
}
X = (DisplayDevice.Default.Width - Width) / 2;
Y = (DisplayDevice.Default.Height - Height) / 2;
public static Polygon operator +(Polygon p, MVec3D m)
{
var pts = new Vector3d[p.Points.Length];
for (var i = 0; i < p.Points.Length; i++)
pts[i] = (p.Points[i] + m).VectorPart;
return new Polygon(pts, p.Color);
}
_view = Matrix4.LookAt(Vector3.Zero, -new Vector3(1, .6f, 1f), Vector3.UnitZ);
}
public static Polygon operator -(Polygon p, MVec3D m)
{
var pts = new Vector3d[p.Points.Length];
for (var i = 0; i < p.Points.Length; i++)
pts[i] = (p.Points[i] - m).VectorPart;
return new Polygon(pts, p.Color);
}
protected override void OnRenderFrame(FrameEventArgs e)
{
base.OnRenderFrame(e);
public static Polygon operator *(Polygon p, MVec3D m)
{
var pts = new Vector3d[p.Points.Length];
for (var i = 0; i < p.Points.Length; i++)
pts[i] = (p.Points[i] * m).VectorPart;
return new Polygon(pts, p.Color);
}
GL.Viewport(ClientRectangle);
public static Polygon operator ^(Polygon p, MVec3D m)
{
var pts = new Vector3d[p.Points.Length];
for (var i = 0; i < p.Points.Length; i++)
pts[i] = (p.Points[i] ^ m).VectorPart;
return new Polygon(pts, p.Color);
}
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.PointSize(10f);
public static Polygon operator &(Polygon p, MVec3D m)
{
var pts = new Vector3d[p.Points.Length];
for (var i = 0; i < p.Points.Length; i++)
pts[i] = (p.Points[i] & m).VectorPart;
return new Polygon(pts, p.Color);
}
}
GL.PushMatrix();
public class Tetrahedron
{
public readonly Vector3d[] Points;
public Color Color;
public Color WireColor;
GL.MatrixMode(MatrixMode.Projection);
GL.LoadMatrix(ref _proj3d);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref _view);
public Tetrahedron(Vector3d p1, Vector3d p2, Vector3d p3, Vector3d p4) : this(p1, p2, p3, p4, Color.GhostWhite)
{
}
GL.Begin(PrimitiveType.TriangleStrip);
GL.Vertex3(-a - b);
GL.Vertex3(-a + b);
GL.Vertex3(a - b);
GL.Vertex3(a + b);
GL.End();
public Tetrahedron(Vector3d p1, Vector3d p2, Vector3d p3, Vector3d p4, Color color) : this(p1, p2, p3, p4, color, Color.Maroon)
{
}
SwapBuffers();
}
public Tetrahedron(Vector3d p1, Vector3d p2, Vector3d p3, Vector3d p4, Color color, Color wireColor)
{
Color = color;
WireColor = wireColor;
Points = new[] {p1, p2, p3, p4};
}
protected override void OnUpdateFrame(FrameEventArgs e)
{
base.OnUpdateFrame(e);
public void Draw(bool wire = true)
{
if (wire)
{
GL.Begin(PrimitiveType.Lines);
GL.Color3(WireColor);
for (var i = 0; i < 4; i++)
for (var j = i + 1; j < 4; j++)
{
GL.Vertex3(Points[i]);
GL.Vertex3(Points[j]);
}
GL.End();
}
else
{
GL.Begin(PrimitiveType.Triangles);
GL.Color3(Color);
for (var i = 0; i < 4; i++)
for (var j = i + 1; j < 4; j++)
for (var k = j + 1; k < 4; k++)
{
GL.Vertex3(Points[i]);
GL.Vertex3(Points[j]);
GL.Vertex3(Points[k]);
}
GL.End();
}
}
public Polygon Intersection(MVec3D blade, Vector3d pivot)
{
var pts = new Vector3d[4];
for (var i = 0; i < 4; i++)
{
pts[i] = Points[i] - pivot;
}
var a = blade * MVec3D.Unit123;
var sides = new double[4];
for (var i = 0; i < 4; i++)
{
sides[i] = (a & ((pts[i] ^ blade) * ~blade)).E; // normal dot rejection
}
var vecs = new List<Vector3d>(4);
for (var i = 0; i < 4; i++)
{
for (var j = i + 1; j < 4; j++)
{
if (sides[i] * sides[j] >= 0) continue; // both pts on same side
var t = ((blade ^ pts[i]) * ~(blade ^ (pts[j] - pts[i]))).E;
var point = pts[i] + t * (pts[j] - pts[i]);
vecs.Add(point + pivot);
}
}
return new Polygon(vecs.ToArray());
}
}
public class TetrahedronWindow : GameWindow
{
private Matrix4 _proj3d;
private Matrix4 _proj2d;
private Matrix4 _view;
private double _t;
private bool _pause;
private bool _div;
private Tetrahedron _tetra;
private Polygon _polyg;
private MVec3D _b1 = MVec3D.Unit1;
private MVec3D _b2 = MVec3D.Unit3;
private MVec3D _pivot = MVec3D.Zero;
private Polygon _square = new Polygon(new[] {new Vector3d(-1, -1, 0), new Vector3d(-1, 1, 0), new Vector3d(1, -1, 0), new Vector3d(1, 1, 0),}, Color.Red);
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
X = (DisplayDevice.Default.Width - Width) / 2;
Y = (DisplayDevice.Default.Height - Height) / 2;
_tetra = new Tetrahedron(new Vector3d(1, 1, 1), new Vector3d(-1, -1, 1), new Vector3d(-1, 1, -1), new Vector3d(1, -1, -1));
_polyg = new Polygon(new[] {new Vector3d(-1, -1, 0), new Vector3d(-1, 1, 0), new Vector3d(1, -1, 0), new Vector3d(1, 1, 0)});
_view = Matrix4.LookAt(Vector3.Zero, -new Vector3(1, .6f, 1f), Vector3.UnitZ);
}
protected override void OnRenderFrame(FrameEventArgs e)
{
base.OnRenderFrame(e);
GL.Viewport(ClientRectangle);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.PointSize(10f);
GL.PushMatrix();
if (_div)
{
GL.MatrixMode(MatrixMode.Projection);
GL.LoadMatrix(ref _proj2d);
_polyg.Draw();
}
else
{
GL.MatrixMode(MatrixMode.Projection);
GL.LoadMatrix(ref _proj3d);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref _view);
GL.Enable(EnableCap.DepthTest);
_tetra.Draw(wire: false);
GL.Disable(EnableCap.DepthTest);
_polyg.Draw();
GL.Begin(PrimitiveType.Points);
GL.Color3(Color.DarkBlue);
GL.Vertex3(_pivot.VectorPart);
GL.End();
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(_pivot.VectorPart);
GL.Vertex3((_pivot + (_b2 ^ _b1) * MVec3D.Unit123 * .5).VectorPart);
GL.End();
GL.Enable(EnableCap.DepthTest);
_tetra.Draw(wire: true);
}
GL.PopMatrix();
SwapBuffers();
}
protected override void OnUpdateFrame(FrameEventArgs e)
{
base.OnUpdateFrame(e);
_proj3d = Matrix4.CreateOrthographic(6, 6f * Height / Width, -2, 2);
_proj2d = Matrix4.CreateOrthographic(4, 4f * Height / Width, -1, 1);
_t += e.Time;
if (Keyboard[Key.Left])
{
var rot = MVec3D.Rotor(-e.Time, MVec3D.Unit12);
_b1 = rot * _b1 * ~rot; // todo make blade classes
_b2 = rot * _b2 * ~rot;
}
if (Keyboard[Key.Right])
{
var rot = MVec3D.Rotor(e.Time, MVec3D.Unit12);
_b1 = rot * _b1 * ~rot;
_b2 = rot * _b2 * ~rot;
}
if (Keyboard[Key.Up])
{
_pivot -= (_b1 ^ _b2) * MVec3D.Unit123 * e.Time;
}
if (Keyboard[Key.Down])
{
_pivot += (_b1 ^ _b2) * MVec3D.Unit123 * e.Time;
}
if (_pause)
return;
// var b1 = MVec3d.Unit2;
// var b2 = MVec3d.Unit3;
// var pivot = new Vector3d(Math.Cos(_t), 0, 0);
// var b1 = MVec3d.Vector(0, Math.Cos(_t * .2), Math.Sin(_t * .5));
// var b2 = MVec3d.Vector(Math.Cos(_t * .6), 0, Math.Sin(_t * .4));
// var pivot = Vector3d.Zero;
// var b1 = MVec3d.Vector(Math.Cos(_t/2), Math.Sin(_t/2), 0);
// var b2 = MVec3d.Unit3;
// var pivot = Vector3d.Zero;
// var blade = MVec3d.Outer(b1, b2);
// var rot = MVec3d.Complex(_t / 2, MVec3d.Unit12);
// var b1 = rot * MVec3d.Unit2 * ~rot;
// var b2 = rot * MVec3d.Unit3 * ~rot;
// var pln = MVec3d.Outer(b1, b2);
// var blade = pln;
// var pivot = Vector3d.Zero;
_polyg = _tetra.Intersection(_b1 ^ _b2, _pivot.VectorPart);
if (_div)
{
var px = ((_pivot & _b1) * ~_b1) & _b1;
var py = ((_pivot ^ _b1) * ~_b1) & ((_b2 ^ _b1) * ~_b1);
for (var i = 0; i < _polyg.Points.Length; i++)
{
MVec3D p = _polyg.Points[i];
var x = ((p & _b1) * ~_b1) & _b1;
var y = ((p ^ _b1) * ~_b1) & ((_b2 ^ _b1) * ~_b1);
_polyg.Points[i] = new Vector3d(x.E - px.E, y.E - py.E, 0);
}
}
}
protected override void OnKeyDown(KeyboardKeyEventArgs e)
{
base.OnKeyDown(e);
switch (e.Key)
{
case Key.Space:
_pause = !_pause;
break;
case Key.A:
_div = !_div;
break;
case Key.R:
_b1 = MVec3D.Unit1;
_b2 = MVec3D.Unit3;
_pivot = MVec3D.Zero;
break;
}
}
}
_proj3d = Matrix4.CreateOrthographic(6, 6f * Height / Width, -2, 2);
}
}
}

1
Tetrahedrons/Tetrahedrons.csproj
View File

@@ -42,7 +42,6 @@
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="MVec3d.cs" />
<Compile Include="MVec4D.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />