public void TestIsLittleEndian()
{
Assert.False(HdrImage.isLittleEndian("1.0"), "TestIsLittleEndian failed - Assert 1/4");
Assert.True(HdrImage.isLittleEndian("-1.0"), "TestIsLittleEndian failed - Assert 2/4");
Assert.Throws <InvalidPfmFileFormat>(() => HdrImage.isLittleEndian("2.0"));
Assert.Throws <InvalidPfmFileFormat>(() => HdrImage.isLittleEndian("abc"));
}
public void TestFlatRender()
{
Color sphereColor = new Color(1f, 2f, 3f);
Sphere sphere = new Sphere(
transformation: Transformation.Translation(new Vec(2f, 0f, 0f)) * Transformation.Scaling(new Vec(0.2f, 0.2f, 0.2f)),
material: new Material(Brdf: new DiffuseBRDF(pig: new UniformPigment(sphereColor)))
);
HdrImage image = new HdrImage(3, 3);
OrthogonalCamera camera = new OrthogonalCamera();
ImageTracer tracer = new ImageTracer(image, camera);
World world = new World();
world.addShape(sphere);
FlatRender renderer = new FlatRender(world);
tracer.fireAllRays(renderer);
Assert.True(image.getPixel(0, 0).isClose(Constant.Black), "TestFlatRender failed - Assert 1/9");
Assert.True(image.getPixel(1, 0).isClose(Constant.Black), "TestFlatRender failed - Assert 2/9");
Assert.True(image.getPixel(2, 0).isClose(Constant.Black), "TestFlatRender failed - Assert 3/9");
Assert.True(image.getPixel(0, 1).isClose(Constant.Black), "TestFlatRender failed - Assert 4/9");
Assert.True(image.getPixel(1, 1).isClose(sphereColor), "TestFlatRender failed - Assert 5/9");
Assert.True(image.getPixel(2, 1).isClose(Constant.Black), "TestFlatRender failed - Assert 6/9");
Assert.True(image.getPixel(0, 2).isClose(Constant.Black), "TestFlatRender failed - Assert 7/9");
Assert.True(image.getPixel(1, 2).isClose(Constant.Black), "TestFlatRender failed - Assert 8/9");
Assert.True(image.getPixel(2, 2).isClose(Constant.Black), "TestFlatRender failed - Assert 9/9");
}
public void TestSavePfm()
{
var MyImg = new HdrImage(3, 2);
//Naive method
MyImg.setPixel(0, 0, new Color(10.0f, 20.0f, 30.0f));
MyImg.setPixel(1, 0, new Color(40.0f, 50.0f, 60.0f));
MyImg.setPixel(2, 0, new Color(70.0f, 80.0f, 90.0f));
MyImg.setPixel(0, 1, new Color(100.0f, 200.0f, 300.0f));
MyImg.setPixel(1, 1, new Color(400.0f, 500.0f, 600.0f));
MyImg.setPixel(2, 1, new Color(700.0f, 800.0f, 900.0f));
byte[] ref_bytes = { 0x50, 0x46, 0x0a, 0x33, 0x20, 0x32, 0x0a, 0x2d, 0x31, 0x2e, 0x30, 0x0a, // Header
0x00, 0x00, 0xc8, 0x42, 0x00, 0x00, 0x48, 0x43, 0x00, 0x00, 0x96, 0x43, // Raster starts here
0x00, 0x00, 0xc8, 0x43, 0x00, 0x00, 0xfa, 0x43, 0x00, 0x00, 0x16, 0x44,
0x00, 0x00, 0x2f, 0x44, 0x00, 0x00, 0x48, 0x44, 0x00, 0x00, 0x61, 0x44,
0x00, 0x00, 0x20, 0x41, 0x00, 0x00, 0xa0, 0x41, 0x00, 0x00, 0xf0, 0x41,
0x00, 0x00, 0x20, 0x42, 0x00, 0x00, 0x48, 0x42, 0x00, 0x00, 0x70, 0x42,
0x00, 0x00, 0x8c, 0x42, 0x00, 0x00, 0xa0, 0x42, 0x00, 0x00, 0xb4, 0x42 };
using (MemoryStream memSt = new MemoryStream(84))
{
MyImg.savePfm(memSt);
Assert.True(memSt.GetBuffer().SequenceEqual(ref_bytes), "TestSavePfm failed - Assert 1/1");
}
}
public void TestPointLightRenderer1()
{
World world = new World();
world.addPointLight(new PointLight(new Point(10f, 10f, 10f), Constant.White));
world.addShape(new Sphere(Transformation.Translation(new Vec(10f, 10f, 10f))));
Sphere sphere = new Sphere(
transformation: Transformation.Translation(new Vec(2f, 0f, 0f)) * Transformation.Scaling(new Vec(0.2f, 0.2f, 0.2f)),
material: new Material(Brdf: new DiffuseBRDF(pig: new UniformPigment(Constant.White))));
HdrImage image = new HdrImage(3, 3);
OrthogonalCamera camera = new OrthogonalCamera();
ImageTracer tracer = new ImageTracer(i: image, c: camera);
world.addShape(sphere);
PointLightRender renderer = new PointLightRender(world);
tracer.fireAllRays(renderer);
Assert.True(image.getPixel(0, 0).isClose(renderer.backgroundColor), "TestPointLight rendered failed (light source shielded by a sphere) - Assert 1/9");
Assert.True(image.getPixel(1, 0).isClose(renderer.backgroundColor), "TestPointLight rendered failed (light source shielded by a sphere) - Assert 2/9");
Assert.True(image.getPixel(2, 0).isClose(renderer.backgroundColor), "TestPointLight rendered failed (light source shielded by a sphere) - Assert 3/9");
Assert.True(image.getPixel(0, 1).isClose(renderer.backgroundColor), "TestPointLight rendered failed (light source shielded by a sphere) - Assert 4/9");
Assert.True(image.getPixel(1, 1).isClose(renderer.ambientColor), "TestPointLight rendered failed (light source shielded by a sphere) - Assert 5/9");
Assert.True(image.getPixel(2, 1).isClose(renderer.backgroundColor), "TestPointLight rendered failed (light source shielded by a sphere) - Assert 6/9");
Assert.True(image.getPixel(0, 2).isClose(renderer.backgroundColor), "TestPointLight rendered failed (light source shielded by a sphere) - Assert 7/9");
Assert.True(image.getPixel(1, 2).isClose(renderer.backgroundColor), "TestPointLight rendered failed (light source shielded by a sphere) - Assert 8/9");
Assert.True(image.getPixel(2, 2).isClose(renderer.backgroundColor), "TestPointLight rendered failed (light source shielded by a sphere) - Assert 9/9");
}
public void TestAverageLumi()
{
HdrImage img = new HdrImage(2, 1);
img.setPixel(0, 0, new Color(5.0f, 10.0f, 15.0f));
img.setPixel(1, 0, new Color(500.0f, 1000.0f, 1500.0f));
Assert.True(Utility.areClose(img.averageLumi(), 100.0f), "TestAverageLumi failed - Assert 1/1");
}
public void TestReadPfm()
{
var MyImg = new HdrImage(3, 2);
byte[] LE_REFERENCE_BYTES =
{
0x50, 0x46, 0x0a, 0x33, 0x20, 0x32, 0x0a, 0x2d, 0x31, 0x2e, 0x30, 0x0a,
0x00, 0x00, 0xc8, 0x42, 0x00, 0x00, 0x48, 0x43, 0x00, 0x00, 0x96, 0x43,
0x00, 0x00, 0xc8, 0x43, 0x00, 0x00, 0xfa, 0x43, 0x00, 0x00, 0x16, 0x44,
0x00, 0x00, 0x2f, 0x44, 0x00, 0x00, 0x48, 0x44, 0x00, 0x00, 0x61, 0x44,
0x00, 0x00, 0x20, 0x41, 0x00, 0x00, 0xa0, 0x41, 0x00, 0x00, 0xf0, 0x41,
0x00, 0x00, 0x20, 0x42, 0x00, 0x00, 0x48, 0x42, 0x00, 0x00, 0x70, 0x42,
0x00, 0x00, 0x8c, 0x42, 0x00, 0x00, 0xa0, 0x42, 0x00, 0x00, 0xb4, 0x42
};
using (MemoryStream memSt = new MemoryStream(LE_REFERENCE_BYTES.Length))
{
memSt.Write(LE_REFERENCE_BYTES);
memSt.Seek(0, SeekOrigin.Begin);
MyImg.readPfm(memSt);
}
Assert.True(MyImg.width == 3, "TestReadPfm failed - Assert 1/16");
Assert.True(MyImg.height == 2, "TestReadPfm failed - Assert 2/16");
Assert.True(MyImg.getPixel(0, 0).isClose(new Color(10.0f, 20.0f, 30.0f)), "TestReadPfm failed - Assert 3/16");
Assert.True(MyImg.getPixel(1, 0).isClose(new Color(40.0f, 50.0f, 60.0f)), "TestReadPfm failed - Assert 4/16");
Assert.True(MyImg.getPixel(2, 0).isClose(new Color(70.0f, 80.0f, 90.0f)), "TestReadPfm failed - Assert 5/16");
Assert.True(MyImg.getPixel(0, 1).isClose(new Color(100.0f, 200.0f, 300.0f)), "TestReadPfm failed - Assert 6/16");
Assert.True(MyImg.getPixel(1, 1).isClose(new Color(400.0f, 500.0f, 600.0f)), "TestReadPfm failed - Assert 7/16");
Assert.True(MyImg.getPixel(2, 1).isClose(new Color(700.0f, 800.0f, 900.0f)), "TestReadPfm failed - Assert 8/16");
byte[] BE_REFERENCE_BYTES =
{
0x50, 0x46, 0x0a, 0x33, 0x20, 0x32, 0x0a, 0x31, 0x2e, 0x30, 0x0a, 0x42,
0xc8, 0x00, 0x00, 0x43, 0x48, 0x00, 0x00, 0x43, 0x96, 0x00, 0x00, 0x43,
0xc8, 0x00, 0x00, 0x43, 0xfa, 0x00, 0x00, 0x44, 0x16, 0x00, 0x00, 0x44,
0x2f, 0x00, 0x00, 0x44, 0x48, 0x00, 0x00, 0x44, 0x61, 0x00, 0x00, 0x41,
0x20, 0x00, 0x00, 0x41, 0xa0, 0x00, 0x00, 0x41, 0xf0, 0x00, 0x00, 0x42,
0x20, 0x00, 0x00, 0x42, 0x48, 0x00, 0x00, 0x42, 0x70, 0x00, 0x00, 0x42,
0x8c, 0x00, 0x00, 0x42, 0xa0, 0x00, 0x00, 0x42, 0xb4, 0x00, 0x00
};
using (MemoryStream memSt = new MemoryStream(BE_REFERENCE_BYTES.Length))
{
memSt.Write(BE_REFERENCE_BYTES);
memSt.Seek(0, SeekOrigin.Begin);
MyImg.readPfm(memSt);
}
Assert.True(MyImg.width == 3, "TestReadPfm failed - Assert 9/16");
Assert.True(MyImg.height == 2, "TestReadPfm failed - Assert 10/16");
Assert.True(MyImg.getPixel(0, 0).isClose(new Color(10.0f, 20.0f, 30.0f)), "TestReadPfm failed - Assert 11/16");
Assert.True(MyImg.getPixel(1, 0).isClose(new Color(40.0f, 50.0f, 60.0f)), "TestReadPfm failed - Assert 12/16");
Assert.True(MyImg.getPixel(2, 0).isClose(new Color(70.0f, 80.0f, 90.0f)), "TestReadPfm failed - Assert 13/16");
Assert.True(MyImg.getPixel(0, 1).isClose(new Color(100.0f, 200.0f, 300.0f)), "TestReadPfm failed - Assert 14/16");
Assert.True(MyImg.getPixel(1, 1).isClose(new Color(400.0f, 500.0f, 600.0f)), "TestReadPfm failed - Assert 15/16");
Assert.True(MyImg.getPixel(2, 1).isClose(new Color(700.0f, 800.0f, 900.0f)), "TestReadPfm failed - Assert 16/16");
}
public void TestReadLine()
{
byte[] byteArray = Encoding.ASCII.GetBytes("hello\nworld");
MemoryStream line = new MemoryStream(byteArray);
Assert.True(HdrImage.readLine(line) == "hello", "TestReadLine failed - Assert 1/3");
Assert.True(HdrImage.readLine(line) == "world", "TestReadLine failed - Assert 2/3");
Assert.True(HdrImage.readLine(line) == "", "TestReadLine failed - Assert 3/3");
}
public void TestOrientation()
{
HdrImage image = new HdrImage(4, 2);
PerspectiveCamera camera = new PerspectiveCamera(aspectRatio: 2.0f);
ImageTracer tracer = new ImageTracer(image, camera);
Ray topLeftRay = tracer.fireRay(0, 0, 0.0f, 0.0f);
Point p = new Point(0.0f, 2.0f, 1.0f);
Assert.True(p.isClose(topLeftRay.at(1.0f)));
}
public void TestUVSubMapping()
{
HdrImage image = new HdrImage(4, 2);
PerspectiveCamera camera = new PerspectiveCamera(aspectRatio: 2.0f);
ImageTracer tracer = new ImageTracer(image, camera);
Ray ray1 = tracer.fireRay(0, 0, 2.5f, 1.5f);
Ray ray2 = tracer.fireRay(2, 1, 0.5f, 0.5f);
Assert.True(ray1.isClose(ray2), "TestUVSubMapping failed - Assert 1/1");
}
public void TestNormalizeImage()
{
var img = new HdrImage(2, 1);
img.setPixel(0, 0, new Color(0.5e1f, 1.0e1f, 1.5e1f));
img.setPixel(1, 0, new Color(0.5e3f, 1.0e3f, 1.5e3f));
img.normalizeImage(factor: 1000.0f, luminosity: 100.0f);
Assert.True(img.getPixel(0, 0).isClose(new Color(0.5e2f, 1.0e2f, 1.5e2f)), "TestNormalizeImage failed - Assert 1/2");
Assert.True(img.getPixel(1, 0).isClose(new Color(0.5e4f, 1.0e4f, 1.5e4f)), "TestNormalizeImage failed - Assert 2/2");
}
public static void ExecuteConvert(string inputpfm, string outputldr, float factor, float gamma, float? luminosity)
{
string fmt = outputldr.Substring(outputldr.Length - 3, 3);
Console.WriteLine("\n\nStarting file conversion using these parameters:\n");
Console.WriteLine("pfmFile: " + inputpfm);
Console.WriteLine("ldrFile: " + outputldr);
Console.WriteLine("Format: " + fmt);
Console.WriteLine("Factor: " + factor);
Console.WriteLine("Gamma: " + gamma);
Console.WriteLine(luminosity.HasValue ? ("Manual luminosity: " + luminosity) : "Average luminosity");
Console.WriteLine("\n");
HdrImage myImg = new HdrImage();
try
{
using (FileStream inputStream = File.OpenRead(inputpfm))
{
myImg.readPfm(inputStream);
Console.WriteLine($"File {inputpfm} has been correctly read from disk.");
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return;
}
Console.WriteLine("Starting Tone Mapping...");
try
{
Console.WriteLine(">>>> Normalizing image...");
if (luminosity.HasValue) myImg.normalizeImage(factor, luminosity.Value);
else myImg.normalizeImage(factor);
Console.WriteLine(">>>> Clamping image...");
myImg.clampImage();
Console.WriteLine(">>>> Saving LDR image...");
myImg.writeLdrImage(outputldr, fmt, gamma);
Console.WriteLine($"File {outputldr} has been correctly written to disk.");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return;
}
} //Convert
public void TestParseImageSize()
{
Assert.True(HdrImage.parseImageSize("3 2").SequenceEqual(new List <int>()
{
3, 2
}), "TestParseImageSize failed - Assert 1/6");
Assert.Throws <InvalidPfmFileFormat>(() => HdrImage.parseImageSize("-1 2"));
Assert.Throws <InvalidPfmFileFormat>(() => HdrImage.parseImageSize("1 -2"));
Assert.Throws <InvalidPfmFileFormat>(() => HdrImage.parseImageSize("3 2 1"));
Assert.Throws <InvalidPfmFileFormat>(() => HdrImage.parseImageSize("3"));
Assert.Throws <InvalidPfmFileFormat>(() => HdrImage.parseImageSize("a b"));
}
public void TestImageCoverage()
{
HdrImage image = new HdrImage(4, 2);
PerspectiveCamera camera = new PerspectiveCamera();
ImageTracer tracer = new ImageTracer(image, camera);
tracer.fireAllRays((Ray r) => new Color(1f, 2f, 3f));
for (int row = 0; row < image.height; row++)
{
for (int col = 0; col < image.width; col++)
{
Assert.True(image.getPixel(col, row).isClose(new Color(1.0f, 2.0f, 3.0f)), $"TestImageCoverage failed - Assert row={row}, col={col}");
}
}
} //end of function
public void TestImagePigment()
{
HdrImage image = new HdrImage(2, 2);
image.setPixel(0, 0, new Color(1.0f, 2.0f, 3.0f));
image.setPixel(1, 0, new Color(2.0f, 3.0f, 1.0f));
image.setPixel(0, 1, new Color(2.0f, 1.0f, 3.0f));
image.setPixel(1, 1, new Color(3.0f, 2.0f, 1.0f));
ImagePigment pig = new ImagePigment(image);
Assert.True(pig.getColor(new Vec2D(0f, 0f)).isClose(new Color(1.0f, 2.0f, 3.0f)), "Test failed, 1/4");
Assert.True(pig.getColor(new Vec2D(0f, 1f)).isClose(new Color(2.0f, 1.0f, 3.0f)), "Test failed, 2/4");
Assert.True(pig.getColor(new Vec2D(1f, 0f)).isClose(new Color(2.0f, 3.0f, 1.0f)), "Test failed, 3/4");
Assert.True(pig.getColor(new Vec2D(1f, 1f)).isClose(new Color(3.0f, 2.0f, 1.0f)), "Test failed, 4/4");
}
public void TestClampImage()
{
var img = new HdrImage(2, 1);
img.setPixel(0, 0, new Color(0.5e1f, 1.0e1f, 1.5e1f));
img.setPixel(1, 0, new Color(0.5e3f, 1.0e3f, 1.5e3f));
img.clampImage();
foreach (var curPixel in img.pixel)
{
Assert.True((curPixel.r >= 0) && (curPixel.r <= 1), "TestClampImage failed - Assert 1/3");
Assert.True((curPixel.g >= 0) && (curPixel.g <= 1), "TestClampImage failed - Assert 2/3");
Assert.True((curPixel.b >= 0) && (curPixel.b <= 1), "TestClampImage failed - Assert 3/3");
}
}
//public static Mesh CupMesh;
public static void LoadScenes()
{
StoneTexture = new HdrImage((Bitmap)Image.FromFile(@"Textures\stone.png"));
WoodTexture = new HdrImage((Bitmap)Image.FromFile(@"Textures\wood1.jpg"));
BrickTexture = new HdrImage((Bitmap)Image.FromFile(@"Textures\01.JPG"));
GravelTexture = new HdrImage((Bitmap)Image.FromFile(@"Textures\03.JPG"));
GraceProbeTextuere = new HdrImage(@"SkyMaps\grace_probe.float");
MugMesh = new Mesh(@"Meshes\mug.obj", new Material(Colors.White, kreflection: 0f, kspecular: 20, kdiffuse: 1f));
//CupMesh = new Mesh(@"Meshes\mug.obj", new Material(Colors.White, 0.1f));
Scenes["CornellBox"] = CornellBoxScene.Scene;
Scenes["AlotOfSpheres"] = AlotOfSpheres.Scene;
Scenes["SkyBoxScene"] = SkyBoxScene.Scene;
Scenes["AntiAliasingScene"] = AntiAliasingScene.Scene;
Scenes["DepthOfFielScene"] = DepthOfFielScene.Scene;
Scenes["CornelBoxScenePathCasting"] = CornelBoxScenePathCasting.Scene;
Scenes["MugScene"] = MugScene.Scene;
Scenes["MugScene"].UseAccelerationStructures = false;
}
public static void ExecuteRender(string file, int width, int height, string pfmFile,
string ldrFile, int spp, char rend, Dictionary<string, float> variables,
float factor, float gamma, int maxDepth, int nRays, int rrLimit)
{
Console.WriteLine($"File describing the scene: {file}");
Console.WriteLine($"Image size: {width}x{height}");
Console.WriteLine($"Output PFM-file: {pfmFile}");
Console.WriteLine($"Output LDR-file: {ldrFile}");
Console.WriteLine($"Samples-per-pixel (antialiasing): {spp}");
// Console.WriteLine($"Maximum ray depth: {maxDepth}");
// Console.WriteLine($"Number of sampled rays: {nRays}");
// Console.WriteLine($"Russian Roulette Lower Limit: {rrLimit}");
Console.WriteLine("User-defined overridden variables");
if (variables.Count == 0) Console.WriteLine(" - No Variables");
foreach (var item in variables)
{
Console.WriteLine($" - {item.Key} = {item.Value}");
}
Scene scene = new Scene();
using (FileStream inputSceneStream = File.OpenRead(file))
{
try
{
scene = Scene.parseScene(inputFile: new InputStream(stream: inputSceneStream, fileName: file), variables: variables);
}
catch (GrammarError e)
{
SourceLocation loc = e.sourceLocation;
Console.WriteLine($"{loc.fileName}:{loc.lineNum}:{loc.colNum}: {e.Message}");
return;
}
}
HdrImage image = new HdrImage(width, height);
// Run the ray-tracer
ImageTracer tracer = new ImageTracer(i: image, c: scene.camera, sps: (int)MathF.Sqrt(spp));
Render renderer;
if (rend == 'o')
{
Console.WriteLine("\nUsing on/off renderer:");
renderer = new OnOffRender(world: scene.world, background: CC.Black);
}
else if (rend == 'f')
{
Console.WriteLine("\nUsing flat renderer:");
renderer = new FlatRender(world: scene.world, background: CC.Black);
}
else if (rend == 'r')
{
Console.WriteLine("\nUsing a path tracer:");
renderer = new PathTracer(world: scene.world, numOfRays: nRays, maxDepth: maxDepth, russianRouletteLimit: rrLimit);
Console.WriteLine($">>>> Max depth: {((PathTracer)renderer).maxDepth}");
Console.WriteLine($">>>> Russian Roulette Limit: {((PathTracer)renderer).russianRouletteLimit}");
Console.WriteLine($">>>> Number of rays: {((PathTracer)renderer).numOfRays}");
}
else if (rend == 'p')
{
Console.WriteLine("\nUsing a point-light tracer: ");
renderer = new PointLightRender(world: scene.world, background: CC.Black);
Console.WriteLine($">> Ambient color: {((PointLightRender)renderer).ambientColor}");
}
else
{
Console.WriteLine($"Unknown renderer: {rend}");
return;
}
Stopwatch sw = new Stopwatch();
sw.Start();
tracer.fireAllRays(renderer);
Console.WriteLine("Saving in pfm format...");
using (FileStream outpfmstream = File.OpenWrite(pfmFile))
{
image.savePfm(outpfmstream);
Console.WriteLine($"Image saved in {pfmFile}");
}
Convert.ExecuteConvert(pfmFile, ldrFile, factor, gamma, null);
sw.Stop();
TimeSpan ts = sw.Elapsed;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
Console.WriteLine("\nRun Time: " + elapsedTime);
Console.WriteLine("See you next time!\n");
} //RenderScene
public LightProbe(Vector3 pos, float radius, HdrImage image)
{
_center = pos;
_radius = radius;
Material = new Material(image, Material.ProjectionMode.LightProbe, new Tiling(), 0, 0, 0, 0, 1f);
}
public static void ExecuteDemo(int width, int height, int angle, bool orthogonal, string pfmFile,
string ldrFile, int scene, float?luminosity, int spp, char rendType)
{
Stopwatch sw = new Stopwatch();
sw.Start();
Console.WriteLine("Starting Demo with these parameters:\n");
Console.WriteLine("Width: " + width + " pixels");
Console.WriteLine("Height: " + height + " pixels");
Console.WriteLine("Angle: " + angle + " degrees");
Console.WriteLine(orthogonal ? "Orthogonal Camera" : "Perspective Camera");
Console.WriteLine("pfmFile: " + pfmFile);
Console.WriteLine("ldrFile: " + ldrFile);
Console.WriteLine("Samples per pixel: " + spp);
Console.WriteLine("Render type: " + dictRend[rendType]);
Console.WriteLine("\n");
HdrImage image = new HdrImage(width, height);
// Camera initialization
Console.WriteLine("Creating the camera...");
// var cameraTransf = Transformation.RotationZ(Utility.DegToRad(angle)) * Transformation.Translation(-2.0f, 0.0f, 0.5f) * Tsf.RotationY(Utility.DegToRad(15));
var cameraTransf = Transformation.Translation(-2.0f, 0.0f, 0.0f);
Camera camera;
if (orthogonal)
{
camera = new OrthogonalCamera(aspectRatio: (float)width / height, transformation: cameraTransf);
}
else
{
camera = new PerspectiveCamera(aspectRatio: (float)width / height, transformation: cameraTransf);
}
// Default value on/off renderer
Render?renderer = null;
Console.WriteLine("Creating the scene...");
World world = new World();
List <float> Vertices = new List <float>()
{
-0.5f, 0.5f
};
switch (scene)
{
case 1:
//One sphere for each vertex of the cube
foreach (var x in Vertices)
{
foreach (var y in Vertices)
{
foreach (var z in Vertices)
{
world.addShape(new Sphere(Tsf.Translation(new Vec(x, y, z))
* Tsf.Scaling(new Vec(0.1f, 0.1f, 0.1f))));
} // z
} // y
} // x
//Adding two more spheres to break simmetry
world.addShape(new Sphere(Tsf.Translation(new Vec(0f, 0f, -0.5f))
* Tsf.Scaling(0.1f)));
world.addShape(new Sphere(Tsf.Translation(new Vec(0f, 0.5f, 0f))
* Tsf.Scaling(0.1f)));
break;
case 2:
HdrImage img = new HdrImage();
string inputpfm = "Texture/CokeTexture.pfm";
using (FileStream inputStream = File.OpenRead(inputpfm))
{
img.readPfm(inputStream);
Console.WriteLine($"Texture {inputpfm} has been correctly read from disk.");
}
Material groundM = new Material(new DiffuseBRDF(new CheckeredPigment(CC.BrightGreen, CC.Orange, 4)), new UniformPigment(CC.Black));
world.addShape(CC.SKY);
world.addShape(new Plane(Tsf.Translation(0f, 0f, -3f), groundM));
world.addShape(
new Cylinder(
transformation: Tsf.Translation(.5f, -1f, -1f) * Transformation.Scaling(.6f, 0.6f, 1.3f) * Tsf.RotationY(Utility.DegToRad(45)),
material: new Material(
Brdf: new DiffuseBRDF(new ImagePigment(img))
//EmittedRadiance: new UniformPigment(CC.Red)// new ImagePigment(img)
)
)
);
world.addShape(
new Cylinder(
transformation: Tsf.Translation(.5f, 1f, -1f) * Transformation.Scaling(.6f, 0.6f, 1.3f) * Tsf.RotationY(Utility.DegToRad(-45)),
material: new Material(
Brdf: new DiffuseBRDF(new ImagePigment(img))
//EmittedRadiance: new UniformPigment(CC.Red)// new ImagePigment(img)
)
)
);
break;
case 3:
PCG pcg = new PCG();
Material sph1Mat = new Material(new DiffuseBRDF(new UniformPigment(CC.BlueChill)));
Material sph2Mat = new Material(new DiffuseBRDF(new UniformPigment(Color.random())));
Material boxMat = new Material(new DiffuseBRDF(new UniformPigment(CC.BrightGreen)));
world.addShape(new Sphere(Tsf.Scaling(500f), CC.skyMat));
world.addShape(new Plane(Tsf.Translation(0f, 0f, -1f), CC.groundMat));
world.addShape(new CSGUnion(new Sphere(Transformation.Translation(0.5f, -2.6f, 1f) * Transformation.Scaling(0.6f), sph2Mat),
new Box(new Point(0f, -2.25f, 0.9f), new Point(1f, -3.25f, 1.8f), null, boxMat)));
world.addShape(new Sphere(Tsf.Translation(3f, 5f, 1.6f) * Tsf.Scaling(2.0f, 4.0f, 2.0f), CC.refMat));
world.addShape(new Sphere(Tsf.Translation(4f, -1f, 1.3f) * Tsf.Scaling(1.0f), sph1Mat));
world.addShape(new Sphere(Tsf.Translation(-4f, -0.5f, 1f) * Tsf.Scaling(2f), sph2Mat));
break;
case 4:
Material mat = new Material(null, new UniformPigment(new Color(10f, 10f, 10f)));
world.addShape(CC.SKY);
world.addShape(new Plane(Tsf.Scaling(-3f, 0f, 0f) * Tsf.RotationY(Utility.DegToRad(270)), mat));
world.addShape(CC.wikiShape(Tsf.RotationZ(Utility.DegToRad(23))));
// world.addShape(CC.wikiShape(Tsf.RotationZ(Utility.DegToRad(45))));
break;
case 5:
Material skyM = new Material(new DiffuseBRDF(new UniformPigment(CC.SkyBlue)), new UniformPigment(CC.SkyBlue));
Material checkered = new Material(new DiffuseBRDF(new CheckeredPigment(CC.Blue, CC.Yellow)), new UniformPigment(CC.Black));
Material ground = new Material(new DiffuseBRDF(new CheckeredPigment(CC.LightRed, CC.Orange)), new UniformPigment(CC.Black));
world.addShape(new Sphere(Tsf.Scaling(500f), skyM));
world.addShape(new Cylinder(Tsf.Translation(0f, 2f, -0.5f) * Tsf.Scaling(0.5f), checkered));
world.addShape(new Cone(r: 0.5f, material: checkered));
world.addShape(new Plane(Tsf.Translation(0f, 0f, -1f), ground));
break;
default:
break;
}
switch (rendType)
{
case 'o':
renderer = new OnOffRender(world);
break;
case 'f':
renderer = new FlatRender(world);
break;
case 'p':
renderer = new PointLightRender(world);
break;
case 'r':
renderer = new PathTracer(world, CC.Black, new PCG());
break;
default:
break;
}
// Ray tracing
Console.WriteLine("Rendering the scene...");
var rayTracer = new ImageTracer(image, camera, (int)Math.Sqrt(spp));
if (renderer == null)
{
renderer = new OnOffRender(world);
}
rayTracer.fireAllRays(renderer);
// Write PFM image
Console.WriteLine("Saving in pfm format...");
using (FileStream outpfmstream = File.OpenWrite(pfmFile))
{
image.savePfm(outpfmstream);
Console.WriteLine($"Image saved in {pfmFile}");
}
Convert.ExecuteConvert(pfmFile, ldrFile, Default.factor, Default.gamma, luminosity);
sw.Stop();
TimeSpan ts = sw.Elapsed;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
Console.WriteLine("RunTime " + elapsedTime);
}//Demo
