public ConcreteKdIntersectionTree(
KdIntersectionTree kdIntersectionTree,
Trafo3d trafo)
{
KdIntersectionTree = kdIntersectionTree;
Trafo = trafo;
}
void ValidateTrafos(Trafo3d a, Trafo3d b)
{
var eq = CheckForwardBackwardConsistency(new Trafo3d(a.Forward, b.Backward)) &&
CheckForwardBackwardConsistency(new Trafo3d(b.Forward, a.Backward));
Assert.True(eq, "trafo not consistent");
}
public static void OrthoNormalOrientation()
{
// Previous implementation
Func <Trafo3d, Trafo3d> reference = trafo =>
{
var x = trafo.Forward.C0.XYZ.Normalized; // TransformDir(V3f.XAxis)
var y = trafo.Forward.C1.XYZ.Normalized; // TransformDir(V3f.YAxis)
var z = trafo.Forward.C2.XYZ.Normalized; // TransformDir(V3f.ZAxis)
y = z.Cross(x).Normalized;
z = x.Cross(y).Normalized;
return(Trafo3d.FromBasis(x, y, z, V3d.Zero));
};
var rnd = new RandomSystem(1);
TrafoTesting.GenericTest(rnd =>
{
var trafo = TrafoTesting.GetRandomTrafo(rnd);
var res = trafo.GetOrthoNormalOrientation();
var res_ref = reference(trafo);
TrafoTesting.AreEqual(res, res_ref);
});
}
void TestDecompose(Trafo3d trafo, Rot3d jitter)
{
var x = (M44d)jitter;
trafo = trafo * new Trafo3d(x, x.Inverse);
V3d r_d, s_d, t_d;
trafo.Decompose(out s_d, out r_d, out t_d);
var recomposed = Trafo3d.FromComponents(s_d, r_d, t_d);
Assert.IsFalse(s_d.AnyNaN || r_d.AnyNaN || t_d.AnyNaN, "something NaN");
var dt = trafo.Forward - recomposed.Forward;
var e = dt.NormMax.Abs();
Assert.IsTrue(e < 1e-9, "DIFF");
var eq = CheckForwardBackwardConsistency(new Trafo3d(trafo.Forward, recomposed.Backward)) &&
CheckForwardBackwardConsistency(new Trafo3d(recomposed.Forward, trafo.Backward));
Assert.True(eq, "trafo not consistent");
}
public MainWindow()
{
InitializeComponent();
Loaded += MainWindow_Loaded;
Aardvark.Base.Aardvark.Init();
var useAardvark = true;
if (useAardvark)
{
app = new Aardvark.Application.WinForms.OpenGlApplication();
app.Initialize(rc, 1);
var renderControl = rc;
var cone = IndexedGeometryPrimitives.solidCone(V3d.OOO, V3d.OOI, 1.0, 0.2, 12, C4b.Red).ToSg(); // build object from indexgeometry primitives
var cube = SgPrimitives.Sg.box(Mod.Init(C4b.Blue), Mod.Init(Box3d.Unit)); // or directly using scene graph
var initialViewTrafo = CameraViewModule.lookAt(V3d.III * 3.0, V3d.OOO, V3d.OOI);
var controlledViewTrafo = Aardvark.Application.DefaultCameraController.control(renderControl.Mouse, renderControl.Keyboard,
renderControl.Time, initialViewTrafo);
var frustum = renderControl.Sizes.Select(size => FrustumModule.perspective(60.0, 0.1, 10.0, size.X / (float)size.Y));
var whiteShader = Aardvark.Base.Rendering.Effects.SimpleLighting.Effect;
var trafo = Effects.Trafo.Effect;
var currentAngle = 0.0;
var angle = renderControl.Time.Select(t =>
{
if (true)
{
return(currentAngle += 0.001);
}
else
{
return(currentAngle);
}
});
var rotatingTrafo = angle.Select((whyCantShadowName) => Trafo3d.RotationZ(whyCantShadowName));
var sg =
new[] { cone, cube.Trafo(rotatingTrafo) }
.ToSg()
.WithEffects(new[] { trafo, whiteShader })
.ViewTrafo(controlledViewTrafo.Select(c => c.ViewTrafo))
.ProjTrafo(frustum.Select(f => f.ProjTrafo()));
renderControl.RenderTask =
Aardvark.Base.RenderTask.ofArray(
new[] {
app.Runtime.CompileClear(renderControl.FramebufferSignature, Mod.Init(C4f.Red)),
app.Runtime.CompileRender(renderControl.FramebufferSignature, sg)
}
);
//var r = new System.Windows.Forms.Form();
//r.Controls.Add(renderControl);
//r.Show();
}
}
/// <summary>
/// </summary>
public Mask3d(V3d cameraPositionInModelSpace, IMask2d mask, Trafo3d model2mask)
{
m_camPosition = cameraPositionInModelSpace;
m_mask = mask;
m_model2mask = model2mask;
m_triangulation = m_mask.ComputeTriangulation();
}
/// <summary>
/// </summary>
public static Mask3d Parse(JObject json, Func <JToken, IMask2d> deserialize)
{
var mask = deserialize(json["mask"]);
var model2mask = Trafo3d.Parse((string)json["model2mask"]);
var camPosition = V3d.Parse((string)json["camPosition"]);
return(new Mask3d(camPosition, mask, model2mask));
}
public void TrafoDecomposeCornerCasesTest()
{
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, V3d.YAxis, V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, V3d.ZAxis, V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, V3d.XAxis, V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, V3d.ZAxis, V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, V3d.YAxis, V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, V3d.XAxis, V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, V3d.YAxis, V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, V3d.ZAxis, V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, V3d.XAxis, V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, V3d.ZAxis, V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, V3d.YAxis, V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, V3d.XAxis, V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, -V3d.YAxis, V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, -V3d.ZAxis, V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, -V3d.XAxis, V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, -V3d.ZAxis, V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, -V3d.YAxis, V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, -V3d.XAxis, V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, V3d.YAxis, -V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, V3d.ZAxis, -V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, V3d.XAxis, -V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, V3d.ZAxis, -V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, V3d.YAxis, -V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, V3d.XAxis, -V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, -V3d.YAxis, V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, -V3d.ZAxis, V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, -V3d.XAxis, V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, -V3d.ZAxis, V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, -V3d.YAxis, V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, -V3d.XAxis, V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, V3d.YAxis, -V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, V3d.ZAxis, -V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, V3d.XAxis, -V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, V3d.ZAxis, -V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, V3d.YAxis, -V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, V3d.XAxis, -V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, -V3d.YAxis, -V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, -V3d.ZAxis, -V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, -V3d.XAxis, -V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, -V3d.ZAxis, -V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, -V3d.YAxis, -V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, -V3d.XAxis, -V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, -V3d.YAxis, -V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, -V3d.ZAxis, -V3d.YAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, -V3d.XAxis, -V3d.ZAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, -V3d.ZAxis, -V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, -V3d.YAxis, -V3d.XAxis));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, -V3d.XAxis, -V3d.YAxis));
}
public void TrafoRotIntoTest()
{
var rnd = new Random();
for (int i = 0; i < 500000; i++)
{
var rx = new V3d(rnd.NextDouble() * 1e-17, 0, 0) * (rnd.Next(100) >= 50 ? 1: -1);
var ry = new V3d(0, rnd.NextDouble() * 1e-17, 0) * (rnd.Next(100) >= 50 ? 1 : -1);
var rz = new V3d(0, 0, rnd.NextDouble() * 1e-17) * (rnd.Next(100) >= 50 ? 1 : -1);
// equal cases
var req = new[]
{
Trafo3d.RotateInto(V3d.XAxis, V3d.XAxis + ry),
Trafo3d.RotateInto(V3d.YAxis, V3d.YAxis + rz),
Trafo3d.RotateInto(V3d.ZAxis, V3d.ZAxis + rx),
};
foreach (var r in req)
{
Assert.True(CheckForwardBackwardConsistency(r));
}
// 180° cases
var r180 = new[]
{
Trafo3d.RotateInto(-V3d.XAxis, V3d.XAxis + ry),
Trafo3d.RotateInto(V3d.XAxis, -V3d.XAxis + rz),
Trafo3d.RotateInto(-V3d.YAxis, V3d.YAxis + rz),
Trafo3d.RotateInto(V3d.YAxis, -V3d.YAxis + rx),
Trafo3d.RotateInto(-V3d.ZAxis, V3d.ZAxis + rx),
Trafo3d.RotateInto(V3d.ZAxis, -V3d.ZAxis + ry)
};
foreach (var r in r180)
{
Assert.True(CheckForwardBackwardConsistency(r));
}
// 90° cases
var r90 = new[]
{
Trafo3d.RotateInto(-V3d.XAxis + rz, V3d.ZAxis),
Trafo3d.RotateInto(V3d.XAxis + ry, V3d.ZAxis),
Trafo3d.RotateInto(-V3d.YAxis + rx, V3d.ZAxis),
Trafo3d.RotateInto(V3d.YAxis + rz, V3d.ZAxis),
Trafo3d.RotateInto(-V3d.XAxis, -V3d.ZAxis + rx),
Trafo3d.RotateInto(V3d.XAxis, -V3d.ZAxis + rx),
Trafo3d.RotateInto(-V3d.YAxis, -V3d.ZAxis + ry),
Trafo3d.RotateInto(V3d.YAxis, -V3d.ZAxis + ry),
};
foreach (var r in r90)
{
Assert.True(CheckForwardBackwardConsistency(r));
}
}
}
private void UpdateProjectionTrafo()
{
var l = m_box.Min.X; var r = m_box.Max.X;
var b = m_box.Min.Y; var t = m_box.Max.Y;
var n = m_box.Min.Z; var f = m_box.Max.Z;
m_trafo = Trafo3d.PerspectiveProjectionRH(l, r, b, t, n, f);
m_trafoChanges.Emit(m_trafo);
}
bool CheckForwardBackwardConsistency(Trafo3d trafo)
{
var i = trafo.Forward * trafo.Backward;
// i should be Identity
return(i.C0.ApproxEqual(V4d.IOOO, 1e-1) &&
i.C1.ApproxEqual(V4d.OIOO, 1e-1) &&
i.C2.ApproxEqual(V4d.OOIO, 1e-1) &&
i.C3.ApproxEqual(V4d.OOOI, 1e-1));
}
public void TrafoRotIntoTest()
{
TrafoTesting.GenericTest((rnd, i) =>
{
var rx = new V3d(rnd.UniformDouble() * 1e-17, 0, 0) * (rnd.UniformDouble() > 0.5 ? 1 : -1);
var ry = new V3d(0, rnd.UniformDouble() * 1e-17, 0) * (rnd.UniformDouble() > 0.5 ? 1 : -1);
var rz = new V3d(0, 0, rnd.UniformDouble() * 1e-17) * (rnd.UniformDouble() > 0.5 ? 1 : -1);
// equal cases
var req = new[]
{
Trafo3d.RotateInto(V3d.XAxis, (V3d.XAxis + ry).Normalized),
Trafo3d.RotateInto(V3d.YAxis, (V3d.YAxis + rz).Normalized),
Trafo3d.RotateInto(V3d.ZAxis, (V3d.ZAxis + rx).Normalized),
};
foreach (var r in req)
{
Assert.True(CheckForwardBackwardConsistency(r));
}
// 180° cases
var r180 = new[]
{
Trafo3d.RotateInto(-V3d.XAxis, (V3d.XAxis + ry).Normalized),
Trafo3d.RotateInto(V3d.XAxis, (-V3d.XAxis + rz).Normalized),
Trafo3d.RotateInto(-V3d.YAxis, (V3d.YAxis + rz).Normalized),
Trafo3d.RotateInto(V3d.YAxis, (-V3d.YAxis + rx).Normalized),
Trafo3d.RotateInto(-V3d.ZAxis, (V3d.ZAxis + rx).Normalized),
Trafo3d.RotateInto(V3d.ZAxis, (-V3d.ZAxis + ry).Normalized)
};
foreach (var r in r180)
{
Assert.True(CheckForwardBackwardConsistency(r));
}
// 90° cases
var r90 = new[]
{
Trafo3d.RotateInto((-V3d.XAxis + rz).Normalized, V3d.ZAxis),
Trafo3d.RotateInto((V3d.XAxis + ry).Normalized, V3d.ZAxis),
Trafo3d.RotateInto((-V3d.YAxis + rx).Normalized, V3d.ZAxis),
Trafo3d.RotateInto((V3d.YAxis + rz).Normalized, V3d.ZAxis),
Trafo3d.RotateInto(-V3d.XAxis, (-V3d.ZAxis + rx).Normalized),
Trafo3d.RotateInto(V3d.XAxis, (-V3d.ZAxis + rx).Normalized),
Trafo3d.RotateInto(-V3d.YAxis, (-V3d.ZAxis + ry).Normalized),
Trafo3d.RotateInto(V3d.YAxis, (-V3d.ZAxis + ry).Normalized),
};
foreach (var r in r90)
{
Assert.True(CheckForwardBackwardConsistency(r));
}
});
}
void ValidateTrafos(Trafo3d a, Trafo3d b)
{
var e = Mat.DistanceMax(a.Forward, b.Forward);
Assert.IsTrue(e.Abs() < 1e-8, "not equal");
var eq = CheckForwardBackwardConsistency(new Trafo3d(a.Forward, b.Backward)) &&
CheckForwardBackwardConsistency(new Trafo3d(b.Forward, a.Backward));
Assert.True(eq, "trafo not consistent");
}
void TestDecompose(V3d scale, V3d rotation, V3d translation)
{
var trafo = Trafo3d.FromComponents(scale, rotation, translation);
V3d r_d, s_d, t_d;
trafo.Decompose(out s_d, out r_d, out t_d);
var recomposed = Trafo3d.FromComponents(s_d, r_d, t_d);
Assert.IsFalse(s_d.AnyNaN || r_d.AnyNaN || t_d.AnyNaN, "something NaN");
ValidateTrafos(trafo, recomposed);
}
public static Trafo3d GetRandomTrafo(RandomSystem rnd, bool withPerspective)
{
var rot = rnd.UniformV3dFull() * Constant.PiTimesFour - Constant.PiTimesTwo;
var trans = rnd.UniformV3dFull() * 10 - 5;
var scale = rnd.UniformV3dFull() * 4 - 2;
var trafo = Trafo3d.FromComponents(scale, rot, trans);
if (withPerspective)
{
trafo *= Trafo3d.PerspectiveProjectionRH(-1, 1, -1, 1, rnd.UniformDouble(), rnd.UniformDouble() * 100);
}
return(trafo);
}
public void VisualHullTest()
{
var view = Trafo3d.ViewTrafoRH(V3d.III, V3d.OOI, V3d.IOO);
var proj = Trafo3d.PerspectiveProjectionOpenGl(-1, 1, -1, 1, 1, 100);
var vpTrafo = view * proj;
var frustumCorners = new Box3d(-V3d.III, V3d.III).ComputeCorners();
//Min, 0 near left bottom
//new V3d(Max.X, Min.Y, Min.Z), 1 near right bottom
//new V3d(Min.X, Max.Y, Min.Z), 2 near left top
//new V3d(Max.X, Max.Y, Min.Z), 3 near right top
//new V3d(Min.X, Min.Y, Max.Z), 4 far left bottom
//new V3d(Max.X, Min.Y, Max.Z), 5 far right bottom
//new V3d(Min.X, Max.Y, Max.Z), 6 far left top
//Max 7 far right top
// use inverse view-projection to get vertices in world space
frustumCorners.Apply(c => vpTrafo.Backward.TransformPosProj(c));
// hull planes should point outside, assume right-handed transformation to build planes
var refHull = new Hull3d(new[]
{
new Plane3d(frustumCorners[0], frustumCorners[2], frustumCorners[4]), // left
new Plane3d(frustumCorners[1], frustumCorners[5], frustumCorners[3]), // right
new Plane3d(frustumCorners[0], frustumCorners[4], frustumCorners[1]), // bottom
new Plane3d(frustumCorners[2], frustumCorners[3], frustumCorners[6]), // top
new Plane3d(frustumCorners[0], frustumCorners[1], frustumCorners[2]), // near
new Plane3d(frustumCorners[4], frustumCorners[6], frustumCorners[5]), // far
});
var newHull = vpTrafo.GetVisualHull();
for (int i = 0; i < 6; i++)
{
Report.Line("OLD: {0} NEW: {1}", newHull.PlaneArray[i], refHull.PlaneArray[i]);
}
// camera position should have height 1.0 from near-plane
var hRef = refHull.PlaneArray[4].Height(view.GetViewPosition());
var hNew = newHull.PlaneArray[4].Height(view.GetViewPosition());
Assert.True(hRef.ApproximateEquals(1.0, 1e-7) && hRef.ApproximateEquals(hNew, 1e-7));
for (int i = 0; i < 6; i++)
{
Assert.True(newHull.PlaneArray[i].Coefficients.ApproxEqual(refHull.PlaneArray[i].Coefficients, 1e-7));
}
}
void TestDecompose(V3d scale, V3d rotation, V3d translation)
{
var trafo = Trafo3d.FromComponents(scale, rotation, translation);
V3d r_d, s_d, t_d;
trafo.Decompose(out s_d, out r_d, out t_d);
var recomposed = Trafo3d.FromComponents(s_d, r_d, t_d);
Assert.IsFalse(s_d.AnyNaN || r_d.AnyNaN || t_d.AnyNaN, "something NaN");
var eq = CheckForwardBackwardConsistency(new Trafo3d(trafo.Forward, recomposed.Backward)) &&
CheckForwardBackwardConsistency(new Trafo3d(recomposed.Forward, trafo.Backward));
Assert.True(eq, "trafo not consistent");
}
void TestDecompose(Trafo3d trafo)
{
trafo = trafo * Trafo3d.RotationXInDegrees(0.000000000000000001);
V3d r_d, s_d, t_d;
trafo.Decompose(out s_d, out r_d, out t_d);
var recomposed = Trafo3d.FromComponents(s_d, r_d, t_d);
Assert.IsFalse(s_d.AnyNaN || r_d.AnyNaN || t_d.AnyNaN, "something NaN");
var eq = CheckForwardBackwardConsistency(new Trafo3d(trafo.Forward, recomposed.Backward)) &&
CheckForwardBackwardConsistency(new Trafo3d(recomposed.Forward, trafo.Backward));
Assert.True(eq, "trafo not consistent");
}
public void ProjectUnprojectTest()
{
var normal = new V3d(-3.38012399699281E-17, -0.000407306344606881, -0.999999917050768);
var distance = -13.109839358218661;
var plane = new Plane3d(normal, distance);
var testPoint = new V3d(-97.076092093139, -148.399088699813, 13.170284341045);
// NOTE: Rot3d in Euclidean3d has numerical issue
var projectedPoint = plane.ProjectToPlaneSpace(testPoint);
var unprojectedPoint = plane.Unproject(projectedPoint);
var planeTrafo = Trafo3d.FromNormalFrame(plane.Point, plane.Normal);
var projectedPoint2 = planeTrafo.Backward.TransformPos(testPoint).Func(x => x.XY);
var unprojectedPoint2 = planeTrafo.Forward.TransformPos(projectedPoint2.Func(x => x.XYO));
Requires.That((unprojectedPoint - unprojectedPoint2).Length < 0.01);
}
public static void Run()
{
using (var app = /*new VulkanApplication() */ new OpenGlApplication())
{
var win = app.CreateSimpleRenderWindow(samples: 8);
var cone = IndexedGeometryPrimitives.Cone.solidCone(V3d.OOO, V3d.OOI, 1.0, 0.2, 48, C4b.Red).ToSg(); // build object from indexgeometry primitives
var cube = SgPrimitives.Sg.box(AValModule.constant(C4b.Blue), AValModule.constant(Box3d.FromCenterAndSize(V3d.Zero, V3d.III))); // or directly using scene graph
var initialViewTrafo = CameraView.LookAt(V3d.III * 3.0, V3d.OOO, V3d.OOI);
var controlledViewTrafo = Aardvark.Application.DefaultCameraController.control(win.Mouse, win.Keyboard,
win.Time, initialViewTrafo);
var frustum = win.Sizes.Map(size => FrustumModule.perspective(60.0, 0.1, 10.0, size.X / (float)size.Y));
var whiteShader = Aardvark.Rendering.Effects.SimpleLighting.Effect;
var trafo = Effects.Trafo.Effect;
var currentAngle = 0.0;
var angle = win.Time.Map(t =>
{
return(currentAngle += 0.001);
});
var rotatingTrafo = angle.Map(a => Trafo3d.RotationZ(a));
var sg =
new[] {
cone.Trafo(AValModule.constant(Trafo3d.Translation(1.0, 1.0, 0.0))),
cube.Trafo(rotatingTrafo)
}
.ToSg()
.WithEffects(new[] { trafo, whiteShader })
.ViewTrafo(controlledViewTrafo.Map(c => c.ViewTrafo))
.ProjTrafo(frustum.Map(f => f.ProjTrafo()));
win.RenderTask =
Aardvark.Rendering.RenderTask.ofArray(
new[] {
app.Runtime.CompileClear(win.FramebufferSignature, AValModule.constant(C4f.Gray10)),
app.Runtime.CompileRender(win.FramebufferSignature, sg)
}
);
win.Run();
}
}
void TestDecompose(V3d scale, V3d rotation, V3d translation)
{
var trafo = Trafo3d.FromComponents(scale, rotation, translation);
V3d r_d, s_d, t_d;
trafo.Decompose(out s_d, out r_d, out t_d);
var recomposed = Trafo3d.FromComponents(s_d, r_d, t_d);
Assert.IsFalse(s_d.AnyNaN || r_d.AnyNaN || t_d.AnyNaN, "something NaN");
var e_scale = (s_d.Abs() - scale.Abs()).LengthSquared;
var e_trans = (t_d - translation).LengthSquared;
Assert.True(e_scale < 1e-5, "Scale");
Assert.True(e_trans < 1e-5, "Translation");
ValidateTrafos(trafo, recomposed);
}
static PixImage RenderSimple(Scene scene, int width, int height, Trafo3d view, Trafo3d proj, Dictionary <uint, EmbreeIndexedGeometry> geos)
{
var img = new PixImage <byte>(width, height, 4);
var mtx = img.GetMatrix <C4b>();
var viewProj = view * proj;
var invViewProj = viewProj.Backward;
RTCFilterFunction filter = null;
//unsafe
//{
// filter = new RTCFilterFunction(ptr =>
// {
// //((uint*)ptr->valid)[0] = 0;
// });
//}
for (int i = 0; i < 20; i++)
{
var sw = Stopwatch.StartNew();
Parallel.For(0, height, new ParallelOptions(), y =>
{
for (int x = 0; x < width; x++)
{
var uv = (new V2d(x, y) + 0.5) / new V2d(width, height);
var ray = GetCameraRay(uv, invViewProj);
var color = GetColor(scene, ray, geos, filter);
mtx[x, y] = color;
}
});
var rayCount = width * height;
var raysPerSecond = rayCount / sw.Elapsed.TotalSeconds / 1e6;
Report.Line("{0:0.00}MRay/s", raysPerSecond);
}
return(img);
}
public void Write(Trafo3d t)
{
Write(t.Forward); Write(t.Backward);
}
public void TrafoDecomposeCornerCasesTest()
{
TrafoTesting.GenericTest((rnd, i) =>
{
var jitter = (i / 100) * 1e-15;
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, V3d.YAxis, V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, V3d.ZAxis, V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, V3d.XAxis, V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, V3d.ZAxis, V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, V3d.YAxis, V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, V3d.XAxis, V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, V3d.YAxis, V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, V3d.ZAxis, V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, V3d.XAxis, V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, V3d.ZAxis, V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, V3d.YAxis, V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, V3d.XAxis, V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, -V3d.YAxis, V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, -V3d.ZAxis, V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, -V3d.XAxis, V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, -V3d.ZAxis, V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, -V3d.YAxis, V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, -V3d.XAxis, V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, V3d.YAxis, -V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, V3d.ZAxis, -V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, V3d.XAxis, -V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, V3d.ZAxis, -V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, V3d.YAxis, -V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, V3d.XAxis, -V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, -V3d.YAxis, V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, -V3d.ZAxis, V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, -V3d.XAxis, V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, -V3d.ZAxis, V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, -V3d.YAxis, V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, -V3d.XAxis, V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, V3d.YAxis, -V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, V3d.ZAxis, -V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, V3d.XAxis, -V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, V3d.ZAxis, -V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, V3d.YAxis, -V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, V3d.XAxis, -V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, -V3d.YAxis, -V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.XAxis, -V3d.ZAxis, -V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, -V3d.XAxis, -V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.YAxis, -V3d.ZAxis, -V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, -V3d.YAxis, -V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(V3d.ZAxis, -V3d.XAxis, -V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, -V3d.YAxis, -V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.XAxis, -V3d.ZAxis, -V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, -V3d.XAxis, -V3d.ZAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.YAxis, -V3d.ZAxis, -V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, -V3d.YAxis, -V3d.XAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
TestDecompose(Trafo3d.FromOrthoNormalBasis(-V3d.ZAxis, -V3d.XAxis, -V3d.YAxis), Rot3d.Rotation(rnd.UniformV3dDirection(), jitter * rnd.UniformDouble()));
});
}
public ConcreteKdIntersectionTree()
{
KdIntersectionTree = new KdIntersectionTree();
Trafo = Trafo3d.Identity;
}
/// <summary>
/// Sets location and axes in a single transaction.
/// </summary>
public void Set(V3d location, V3d right, V3d up, V3d forward)
{
m_trafo = Trafo3d.ViewTrafo(location, right, up, -forward);
m_trafoChanges.Emit(m_trafo);
}
/// <summary> /// Returns a transformation of an orthonormal basis in Plane- to WorldSpace. /// </summary> public static Trafo3d GetPlaneSpaceTransform(this Plane3d self) => Trafo3d.FromNormalFrame(self.Point, self.Normal);
