public void ComputeLrtfForRandomInput()
{
ComplexLens lens = ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0);
LensRayTransferFunction lrtf = new LensRayTransferFunction(lens);
Random random = new Random();
for (int i = 0; i < 1000; i++)
{
var incomingParams = new LensRayTransferFunction.Parameters(
random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextDouble()
);
LensRayTransferFunction.Parameters outgoingParams = lrtf.ComputeLrtf(incomingParams);
if (outgoingParams != null)
{
if (outgoingParams.DirectionTheta < 0 || outgoingParams.DirectionTheta > 1 ||
outgoingParams.DirectionPhi < 0 || outgoingParams.DirectionPhi > 1 ||
outgoingParams.PositionTheta < 0 || outgoingParams.PositionTheta > 1 ||
outgoingParams.PositionPhi < 0 || outgoingParams.PositionPhi > 1)
{
Console.WriteLine("Warning: parameter outside [0; 1] interval.");
Console.WriteLine("incoming: {0}", incomingParams);
Console.WriteLine("outgoing: {0}", outgoingParams);
Console.WriteLine();
}
//Assert.InRange(outgoingParams.DirectionTheta, 0.0, 1.0);
//Assert.InRange(outgoingParams.DirectionPhi, 0.0, 1.0);
//Assert.InRange(outgoingParams.PositionTheta, 0.0, 1.0);
//Assert.InRange(outgoingParams.PositionPhi, 0.0, 1.0);
}
}
}
public void PrepareLrtfLens(ComplexLens lens, string name)
{
int sampleCount = (int)lrtfSampleCountNumeric.Value;
precomputedComplexLens = new PrecomputedComplexLens(lens,
@"data\lrtf_" + name + @"_{0}.bin", sampleCount);
rayTracer.Camera.Lens = precomputedComplexLens;
}
private void PrepareLrtf(ComplexLens lens, int sampleCount)
{
lrtf = new LensRayTransferFunction(lens);
// load precomputed LRTF from a file or compute it and save to file
string filename = string.Format(@"data\lrtf_double_gauss_{0}.bin", sampleCount);
lrtfTable = lrtf.SampleLrtf3DCached(sampleCount, filename);
}
private ComplexLens CreateLens()
{
//double curvatureRadius = 150;
//double apertureRadius = 100;
//return ComplexLens.CreateBiconvexLens(curvatureRadius, apertureRadius, 0);
return(ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0));
//return ComplexLens.CreatePetzvalLens(Materials.Fixed.AIR, 4.0);
}
public void ComputeLrtfResultInCorrectInterval()
{
ComplexLens lens = ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0);
LensRayTransferFunction lrtf = new LensRayTransferFunction(lens);
var incomingParams = new LensRayTransferFunction.Parameters(0.835057026164167, 0.375245163857585, 0.854223355117358, 0.000161428470239708);
LensRayTransferFunction.Parameters outgoingParams = lrtf.ComputeLrtf(incomingParams);
Console.WriteLine(outgoingParams);
}
private IList <ComplexLens> CreateLenses()
{
return(new List <ComplexLens>(
new[] {
ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0),
ComplexLens.CreatePetzvalLens(Materials.Fixed.AIR, 4.0),
ComplexLens.CreateBiconvexLens(150, 100, 0)
}
));
}
private static void ConvertParametersToRayAndBack(
LensRayTransferFunction.Parameters inputParams,
Func <LensRayTransferFunction.Parameters, ComplexLens, LensRayTransferFunction.Parameters> func)
{
ComplexLens lens = ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0);
var outputParams = func(inputParams, lens);
Assert.Equal(inputParams.PositionTheta, outputParams.PositionTheta, 5);
Assert.Equal(inputParams.PositionPhi, outputParams.PositionPhi, 5);
Assert.Equal(inputParams.DirectionTheta, outputParams.DirectionTheta, 5);
Assert.Equal(inputParams.DirectionPhi, outputParams.DirectionPhi, 5);
}
public void ComputeLrtf()
{
ComplexLens lens = ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0);
LensRayTransferFunction lrtf = new LensRayTransferFunction(lens);
var incomingParams = new LensRayTransferFunction.Parameters(0.5, 0.5, 0.7000000000000004, 0.0);
LensRayTransferFunction.Parameters outgoingParams = lrtf.ComputeLrtf(incomingParams);
Console.WriteLine("IN: {0}", incomingParams);
Console.WriteLine("OUT: {0}", outgoingParams);
if (outgoingParams != null)
{
Console.WriteLine(" {0}", lens.ConvertParametersToFrontSurfaceRay(outgoingParams));
}
}
public void TraceRays()
{
ComplexLens lens = ComplexLens.CreateBiconvexLens(4, 2, 0);
Sampler sampler = new Sampler();
int sampleCount = 64;
int sqrtSampleCount = (int)Math.Sqrt(sampleCount);
Vector3d objectPos = new Vector3d(10, 0, 100);
foreach (Vector2d sample in sampler.GenerateJitteredSamples(sqrtSampleCount))
{
Vector3d lensPos = lens.GetBackSurfaceSample(sample);
Ray result = lens.Transfer(objectPos, lensPos);
}
}
public ComplexLensForm()
{
InitializeComponent();
complexLens = CreateLens();
if (showAlsoLrtf)
{
PrepareLrtf(complexLens, 128);
}
//directionPhi = Math.PI;
directionPhi = 1.0;
incomingRay = new Ray(new Vector3d(25, 0, 300), new Vector3d(Math.Sin(directionPhi), 0, Math.Cos(directionPhi)));
rayDirectionPhiNumeric.Value = (decimal)directionPhi;
FillVectorToControls(incomingRay.Origin, rayOriginXNumeric, rayOriginYNumeric, rayOriginZNumeric);
initialized = true;
Recompute();
}
static void Main(string[] args)
{
//ComplexLens lens = ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0);
//string lensName = "double_gauss";
ComplexLens lens = ComplexLens.CreatePetzvalLens(Materials.Fixed.AIR, 4.0);
string lensName = "petzval";
//ComplexLens lens = ComplexLens.CreateBiconvexLens(150, 100, 0);
//string lensName = "biconvex";
LensRayTransferFunction lrtf = new LensRayTransferFunction(lens);
int sampleCount = 128;
Stopwatch stopwatch = Stopwatch.StartNew();
var table = lrtf.SampleLrtf3D(sampleCount);
stopwatch.Stop();
//for (int i = 0; i < sampleCount; i++)
//{
// for (int j = 0; j < sampleCount; j++)
// {
// for (int k = 0; k < sampleCount; k++)
// {
// var value = new LensRayTransferFunction.Parameters(table.Table[i, j, k]);
// Console.WriteLine((value != null) ? value.ToString() : "null");
// }
// Console.WriteLine();
// }
//}
Console.WriteLine("Size: {0}x{0}x{0}, elapsed time: {1} ms", sampleCount, stopwatch.ElapsedMilliseconds);
string filename = string.Format(@"data\lrtf_{0}_{1}.bin", lensName, sampleCount);
stopwatch.Reset();
stopwatch.Start();
table.Save(filename);
stopwatch.Stop();
Console.WriteLine("Saved sampled LRTF into file: {0}, elapsed time: {1} ms", filename, stopwatch.ElapsedMilliseconds);
}
public void TraceSingleRay()
{
ComplexLens lens = ComplexLens.CreateBiconvexLens(4, 2, 0);
Sampler sampler = new Sampler();
int sampleCount = 64;
int sqrtSampleCount = (int)Math.Sqrt(sampleCount);
Vector3d objectPos = new Vector3d(10, 0, 100);
Vector3d direction = new Vector3d(0, 0, 0);
Ray ray = new Ray(objectPos, direction);
Intersection isec = lens.Intersect(ray);
if (isec == null)
{
return;
}
Ray result = lens.Transfer(objectPos, isec.Position);
}
public void CompareEvaluationTime()
{
ComplexLens lens = ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0);
LensRayTransferFunction lrtf = new LensRayTransferFunction(lens);
int sampleCount = 128;
Console.WriteLine("LRTF table size: {0}x{0}x{0}", sampleCount);
string filename = string.Format(@"data\lrtf_double_gauss_{0}.bin", sampleCount);
var table = lrtf.SampleLrtf3DCached(sampleCount, filename);
int valueCount = 1000000;
Console.WriteLine("Number of values to evaluate: {0}", valueCount);
Random random = new Random();
var inParams = new List <LensRayTransferFunction.Parameters>();
for (int i = 0; i < valueCount; i++)
{
inParams.Add(new LensRayTransferFunction.Parameters(
random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextDouble()
));
}
Stopwatch stopwatch = Stopwatch.StartNew();
foreach (var inParam in inParams)
{
lrtf.ComputeLrtf(inParam);
}
stopwatch.Stop();
Console.WriteLine("Ray tracing: {0} ms", stopwatch.ElapsedMilliseconds);
stopwatch.Reset();
stopwatch.Start();
foreach (var inParam in inParams)
{
table.EvaluateLrtf3D(inParam);
}
stopwatch.Stop();
Console.WriteLine("LRTF table interpolation: {0} ms", stopwatch.ElapsedMilliseconds);
}
public void SampleLrtf()
{
ComplexLens lens = ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0);
LensRayTransferFunction lrtf = new LensRayTransferFunction(lens);
var defaultParameters = new LensRayTransferFunction.Parameters(0.5, 0.5, 1.0, 0.5);
var table = lrtf.SampleLrtf1D(defaultParameters,
LensRayTransferFunction.VariableParameter.DirectionTheta, 101);
//int i = 0;
//foreach (LensRayTransferFunction.Parameters rayParams in table)
//{
// Console.WriteLine("[{0}]: {1}", i, rayParams);
// if (rayParams != null)
// {
// //Console.WriteLine(" {0}", lens.ConvertParametersToFrontSurfaceRay(rayParams));
// }
// i++;
//}
Console.WriteLine("{{ {0} }}", string.Join(",\n", table.Select((item) => (item != null) ? item.ToString() : "Null").ToArray()));
}
public BiconvexLensForm()
{
InitializeComponent();
biconvexLens = new BiconvexLens()
{
CurvatureRadius = 150,
ApertureRadius = 100,
RefractiveIndex = Materials.Fixed.GLASS_CROWN_BK7
};
complexLens = ComplexLens.CreateBiconvexLens(150, 100, 0);
double directionPhi = Math.PI;
incomingRay = new Ray(new Vector3d(70, 0, 150), new Vector3d(Math.Sin(directionPhi), 0, Math.Cos(directionPhi)));
rayDirectionPhiNumeric.Value = (decimal)directionPhi;
curvatureRadiusNumeric.Value = (decimal)biconvexLens.CurvatureRadius;
apertureRadiusNumeric.Value = (decimal)biconvexLens.ApertureRadius;
FillVectorToControls(incomingRay.Origin, rayOriginXNumeric, rayOriginYNumeric, rayOriginZNumeric);
initialized = true;
Recompute();
}
public void CompareInterpolatedLrtfValueWithOriginalOnes()
{
ComplexLens lens = ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0);
LensRayTransferFunction lrtf = new LensRayTransferFunction(lens);
int sampleCount = 128;
string filename = string.Format(@"data\lrtf_double_gauss_{0}.bin", sampleCount);
var table = lrtf.SampleLrtf3DCached(sampleCount, filename);
Random random = new Random();
for (int i = 0; i < 1000; i++)
{
var incomingParams = new LensRayTransferFunction.Parameters(
random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextDouble()
);
var outgoingParamsOriginal = lrtf.ComputeLrtf(incomingParams).ToVector4d();
var outgoingParamsInterpolated = table.EvaluateLrtf3D(incomingParams).ToVector4d();
//AssertEqualVector4d(outgoingParamsOriginal, outgoingParamsInterpolated);
}
}
public void SampleLrtfSaveLoadAndCompare()
{
ComplexLens lens = ComplexLens.CreateDoubleGaussLens(Materials.Fixed.AIR, 4.0);
LensRayTransferFunction lrtf = new LensRayTransferFunction(lens);
int sampleCount = 16;
var table = lrtf.SampleLrtf3D(sampleCount);
Console.WriteLine("Size: {0}x{0}x{0}", sampleCount);
string filename = string.Format("lrtf_double_gauss_{0}.bin", sampleCount);
table.Save(filename);
Console.WriteLine("Saved sampled LRTF into file: {0}", filename);
Console.WriteLine("Trying to load sampled LRTF from file and compare...");
var recoveredTable = LensRayTransferFunction.Table3d.Load(filename);
Assert.Equal(sampleCount, recoveredTable.Size);
for (int i = 0; i < sampleCount; i++)
{
for (int j = 0; j < sampleCount; j++)
{
for (int k = 0; k < sampleCount; k++)
{
Vector4d orig = table.Table[i, j, k];
Vector4d recovered = recoveredTable.Table[i, j, k];
AssertEqualVector4d(orig, recovered);
}
}
}
Console.WriteLine("Compared OK");
}
private void DrawComplexLens(Graphics g, Func <Vector3d, Point> projFunc, ComplexLens lens)
{
float maxApertureRadius = (float)lens.ElementSurfaces.Select(
surface => surface.ApertureRadius).Max();
// draw spheres
foreach (var surface in lens.ElementSurfaces)
{
if (surface.Surface is Sphere)
{
Sphere sphere = (Sphere)surface.Surface;
//DrawCircle(g, Pens.Blue, projFunc(sphere.Center), (float)sphere.Radius);
//FillSquare(g, Brushes.Aquamarine, projFunc(sphere.Center), 3);
DrawSphericalCap(g, sphere, surface.ApertureRadius, surface.Convex);
}
else if (surface.Surface is Circle)
{
Circle circle = (Circle)surface.Surface;
DrawCircularStop(g, Pens.Violet, projFunc(
new Vector3d(0, 0, circle.Z)), (float)circle.Radius, maxApertureRadius);
}
}
}
