public void CombinedImages()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "checkers_left.png");
model.AddImageFromFile(TestData.Directory + "checkers_right.png");
model.Pipelines[0].Color.Formula = "I0 + I1";
model.Apply();
Assert.IsNotNull(model.Pipelines[0].Image);
var colors = model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip0);
TestData.TestCheckersLevel0(colors);
}
public void OptimizeTrivialFormula()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "small.png");
model.AddImageFromFile(TestData.Directory + "small.pfm");
model.Apply();
Assert.IsTrue(ReferenceEquals(model.Pipelines[0].Image, model.Images.Images[0].Image));
model.Pipelines[0].Color.Formula = "I1";
model.Pipelines[0].Alpha.Formula = "I1";
model.Apply();
Assert.IsTrue(ReferenceEquals(model.Pipelines[0].Image, model.Images.Images[1].Image));
}
public void ExportCroppedImage3D()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "checkers3d.dds");
model.Export.Mipmap = 0;
model.Export.UseCropping = true;
model.Export.CropStartX = 1;
model.Export.CropEndX = 2;
model.Export.CropStartY = 0;
model.Export.CropEndY = 1;
model.Export.CropStartZ = 2;
model.Export.CropEndZ = 3;
model.Apply();
model.ExportPipelineImage(ExportDir + "cropped", "dds", GliFormat.RGBA8_SRGB);
var newTex = new Texture3D(IO.LoadImage(ExportDir + "cropped.dds"));
var colors = newTex.GetPixelColors(0);
Assert.AreEqual(2 * 2 * 2, colors.Length);
Assert.IsTrue(Color.White.Equals(colors[0], Color.Channel.Rgb));
Assert.IsTrue(Color.Black.Equals(colors[1], Color.Channel.Rgb));
Assert.IsTrue(Color.White.Equals(colors[2], Color.Channel.Rgb));
Assert.IsTrue(Color.Black.Equals(colors[3], Color.Channel.Rgb));
Assert.IsTrue(Color.White.Equals(colors[4], Color.Channel.Rgb));
Assert.IsTrue(Color.Black.Equals(colors[5], Color.Channel.Rgb));
Assert.IsTrue(Color.White.Equals(colors[6], Color.Channel.Rgb));
Assert.IsTrue(Color.Black.Equals(colors[7], Color.Channel.Rgb));
}
private void CompareAfterExport(string inputImage, string outputImage, string outputExtension, GliFormat format, Color.Channel channels = Color.Channel.Rgb, float tolerance = 0.01f)
{
var model = new Models(1);
model.AddImageFromFile(inputImage);
model.Apply();
var origTex = (TextureArray2D)model.Pipelines[0].Image;
model.Export.Quality = 100;
model.Export.Export(origTex, new ExportDescription(outputImage, outputExtension, model.Export)
{
FileFormat = format
});
var expTex = new TextureArray2D(IO.LoadImage(outputImage + "." + outputExtension));
for (int curLayer = 0; curLayer < origTex.NumLayers; ++curLayer)
{
for (int curMipmap = 0; curMipmap < origTex.NumMipmaps; ++curMipmap)
{
var origColors = origTex.GetPixelColors(curLayer, curMipmap);
var expColor = expTex.GetPixelColors(curLayer, curMipmap);
TestData.CompareColors(origColors, expColor, channels, tolerance);
}
}
}
public void Checkers3D()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "checkers3d.dds");
models.Apply();
// get statistics
var stats = models.GetStatistics(models.Pipelines[0].Image);
// alpha
Assert.AreEqual(1.0f, stats.Alpha.Min);
Assert.AreEqual(1.0f, stats.Alpha.Max);
Assert.AreEqual(1.0f, stats.Alpha.Avg, 0.01f);
// luminance
Assert.AreEqual(0.0f, stats.Luminance.Min);
Assert.AreEqual(1.0f, stats.Luminance.Max, 0.01f);
Assert.AreEqual(0.5f, stats.Luminance.Avg, 0.01f);
// luma
Assert.AreEqual(0.0f, stats.Luma.Min);
Assert.AreEqual(1.0f, stats.Luma.Max, 0.01f);
Assert.AreEqual(0.5f, stats.Luma.Avg, 0.01f);
// average
Assert.AreEqual(0.0f, stats.Average.Min);
Assert.AreEqual(1.0f, stats.Average.Max, 0.01f);
Assert.AreEqual(0.5f, stats.Average.Avg, 0.01f);
// lightness
Assert.AreEqual(0.0f, stats.Lightness.Min);
Assert.AreEqual(100.0f, stats.Lightness.Max, 0.5f);
Assert.AreEqual(50.0f, stats.Lightness.Avg, 0.5f);
}
public void Checkers3DInvert()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "checkers3d.dds");
model.Apply();
Assert.IsTrue(ReferenceEquals(model.Pipelines[0].Image, model.Images.Images[0].Image));
TestData.TestCheckers3DLevel0(model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip0));
TestData.TestCheckers3DLevel1(model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip1));
TestData.TestCheckersLevel2(model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip2));
model.Pipelines[0].Color.Formula = "1 - I0";
model.Apply();
Assert.IsNotNull(model.Pipelines[0].Image);
var tex = model.Pipelines[0].Image;
// compare with checkers texture
TestData.TestCheckersLevel0Inverted(TestData.GetSlice(tex.GetPixelColors(LayerMipmapSlice.Mip0), 0 * 4 * 4, 4 * 4));
TestData.TestCheckersLevel0Inverted(TestData.GetSlice(tex.GetPixelColors(LayerMipmapSlice.Mip0), 1 * 4 * 4, 4 * 4));
TestData.TestCheckersLevel0(TestData.GetSlice(tex.GetPixelColors(LayerMipmapSlice.Mip0), 2 * 4 * 4, 4 * 4));
TestData.TestCheckersLevel0(TestData.GetSlice(tex.GetPixelColors(LayerMipmapSlice.Mip0), 3 * 4 * 4, 4 * 4));
TestData.TestCheckersLevel1Inverted(TestData.GetSlice(tex.GetPixelColors(LayerMipmapSlice.Mip1), 0, 2 * 2));
TestData.TestCheckersLevel1(TestData.GetSlice(tex.GetPixelColors(LayerMipmapSlice.Mip1), 2 * 2, 2 * 2));
}
public void MipmapGeneration()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "checkers.dds");
model.Pipelines[0].Color.Formula = "(I0+1)^2"; // nonlinear transformation on image
model.Pipelines[0].RecomputeMipmaps = true;
model.Apply();
Assert.IsFalse(model.Pipelines[0].HasChanges);
// check image data
var mip1 = model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip1);
Assert.AreEqual(4, mip1.Length);
Assert.IsTrue(mip1[0].Equals(new Color(1.0f), Color.Channel.Rgb));
Assert.IsTrue(mip1[1].Equals(new Color(4.0f), Color.Channel.Rgb));
Assert.IsTrue(mip1[2].Equals(new Color(4.0f), Color.Channel.Rgb));
Assert.IsTrue(mip1[3].Equals(new Color(1.0f), Color.Channel.Rgb));
// test if the highest mipmap was actually recalculated instead of averaged
var mip2 = model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip2);
Assert.AreEqual(1, mip2.Length);
Assert.IsTrue(mip2[0].Equals(new Color(2.5f), Color.Channel.Rgb)); // average of all pixels should be ~2.5
}
public void LogFunctionResults()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "pixel.png");
var eq = models.Pipelines[0].Alpha;
eq.Formula = "log2(1)";
TestFor(models, 0.0f);
eq.Formula = "log(1)";
TestFor(models, 0.0f);
eq.Formula = "log10(1)";
TestFor(models, 0.0f);
eq.Formula = "log2(0)";
TestFor(models, float.NegativeInfinity);
eq.Formula = "log(0)";
TestFor(models, float.NegativeInfinity);
eq.Formula = "log10(0)";
TestFor(models, float.NegativeInfinity);
eq.Formula = "log2(-1)";
TestFor(models, float.NaN);
eq.Formula = "log(-1)";
TestFor(models, float.NaN);
eq.Formula = "log10(-1)";
TestFor(models, float.NaN);
}
public void DdsDirectXCubemapCompability()
{
// load cubemap
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "cubemap.dds");
model.Apply();
// export
var desc = new ExportDescription(model.Pipelines[0].Image, ExportDir + "tmp", "dds");
desc.FileFormat = GliFormat.RGBA8_SRGB;
model.Export.Export(desc);
// try loading with dds loader
DDSTextureLoader.CreateDDSTextureFromFile(Device.Get().Handle, Device.Get().ContextHandle, ExportDir + "tmp.dds",
out var resource, out var resourceView, 0, out var alphaMode);
Assert.AreEqual(ResourceDimension.Texture2D, resource.Dimension);
Assert.IsTrue(resource is Texture2D);
var tex2D = resource as Texture2D;
Assert.AreEqual(model.Images.Size.Width, tex2D.Description.Width);
Assert.AreEqual(model.Images.Size.Height, tex2D.Description.Height);
Assert.AreEqual(model.Images.NumLayers, tex2D.Description.ArraySize);
Assert.AreEqual(model.Images.NumMipmaps, tex2D.Description.MipLevels);
}
public void GammaFilter()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "small.pfm");
var filter = model.CreateFilter("filter/gamma.hlsl");
// set factor to 4
foreach (var param in filter.Parameters)
{
if (param.GetBase().Name == "Factor")
{
param.GetFloatModel().Value = 4.0f;
}
}
model.Filter.AddFilter(filter);
model.Apply();
var colors = model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip0);
// compare with reference image
var refColors = TestData.GetColors("smallx4.pfm");
TestData.CompareColors(refColors, colors);
}
public void ExportCroppedImage3D()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "checkers3d.dds");
model.Apply();
TestData.TestCheckers3DLevel0(model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip0));
model.Export.Export(new ExportDescription(model.Pipelines[0].Image, ExportDir + "cropped", "dds")
{
FileFormat = GliFormat.RGBA8_SRGB,
Mipmap = 0,
UseCropping = true,
CropStart = new Size3(1, 0, 2).ToCoords(model.Images.Size),
CropEnd = new Size3(2, 1, 3).ToCoords(model.Images.Size)
});
var newTex = new Texture3D(IO.LoadImage(ExportDir + "cropped.dds"));
var colors = newTex.GetPixelColors(0);
Assert.AreEqual(2 * 2 * 2, colors.Length);
Assert.IsTrue(Colors.White.Equals(colors[0], Color.Channel.Rgb));
Assert.IsTrue(Colors.Black.Equals(colors[1], Color.Channel.Rgb));
Assert.IsTrue(Colors.White.Equals(colors[2], Color.Channel.Rgb));
Assert.IsTrue(Colors.Black.Equals(colors[3], Color.Channel.Rgb));
Assert.IsTrue(Colors.White.Equals(colors[4], Color.Channel.Rgb));
Assert.IsTrue(Colors.Black.Equals(colors[5], Color.Channel.Rgb));
Assert.IsTrue(Colors.White.Equals(colors[6], Color.Channel.Rgb));
Assert.IsTrue(Colors.Black.Equals(colors[7], Color.Channel.Rgb));
}
public void CropOverlayGrayOutAll()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "small.pfm");
models.Apply();
var crop = new CropOverlay(models);
models.Overlay.Overlays.Add(crop);
crop.Start = null;
crop.End = null;
crop.IsEnabled = true;
var expectedColors = models.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip0);
for (var i = 0; i < expectedColors.Length; i++)
{
expectedColors[i] = expectedColors[i].Scale(0.5f, Color.Channel.Rgb);
}
var actualColors = GetColorAfterExport(models);
TestData.CompareColors(expectedColors, actualColors);
}
public void CropOverlaySimple()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "small.pfm");
models.Apply();
var dim = models.Images.Size;
var crop = new CropOverlay(models);
models.Overlay.Overlays.Add(crop);
// set up cropping
crop.Start = new Size3(1, 2, 0).ToCoords(dim);
crop.End = new Size3(2, 2, 0).ToCoords(dim);
crop.IsEnabled = false;
// nothing should change
var expectedColors = models.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip0);
var actualColors = GetColorAfterExport(models);
TestData.CompareColors(expectedColors, actualColors, Color.Channel.Rgba, 0.0f);
// enable cropping
crop.IsEnabled = true;
// gray out colors
for (int i = 0; i <= 6; ++i)
{
expectedColors[i] = expectedColors[i].Scale(0.5f, Color.Channel.Rgb);
}
actualColors = GetColorAfterExport(models);
TestData.CompareColors(expectedColors, actualColors, Color.Channel.Rgba);
}
public void FastSlowScaling()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "checkers3x7.png");
models.Pipelines[0].Color.Formula = "I0 + 0"; // trick pipeline to create a rgba32 target for us
models.Apply();
var src = models.Pipelines[0].Image;
Assert.IsNotNull(src);
Assert.AreEqual(SharpDX.DXGI.Format.R32G32B32A32_Float, src.Format);
var mipped = src.CloneWithMipmaps(src.Size.MaxMipLevels);
// mip levels:
// 0: 3 x 7
// 1: 1 x 3 fast + slow
// 2: 1 x 1 fast + fast
models.Scaling.WriteMipmaps(mipped);
// test mipmaps
var mip1 = mipped.GetPixelColors(LayerMipmapSlice.Mip1);
var refMip1 = IO.LoadImageTexture(TestData.Directory + "checkers3x7_mip1.png").GetPixelColors(LayerMipmapSlice.Mip0);
TestData.CompareColors(refMip1, mip1);
var mip2 = mipped.GetPixelColors(LayerMipmapSlice.Mip2);
Assert.AreEqual(1, mip2.Length);
Assert.IsTrue(new Color(0.476f).Equals(mip2[0], Color.Channel.Rgb));
}
public override void Execute(List <string> arguments, Models model)
{
foreach (var filename in arguments)
{
model.AddImageFromFile(filename);
}
}
public void Dds3DDirectXCompability()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "checkers3d.dds");
model.Apply();
model.Export.Quality = 100;
var origTex = (Texture3D)model.Pipelines[0].Image;
var origColors = origTex.GetPixelColors(0, 0);
Color[] newColors = null;
var eFmt = model.Export.Formats.First(fmt => fmt.Extension == "dds");
string errors = "";
int numErrors = 0;
int nFormats = 0;
foreach (var format in eFmt.Formats)
{
if (format.IsExcludedFrom3DExport())
{
continue;
}
nFormats++;
try
{
// export to dds
var desc = new ExportDescription(ExportDir + "tmp", "dds", model.Export);
desc.FileFormat = format;
model.Export.Export(origTex, desc);
// load with directx dds loader
DDSTextureLoader.CreateDDSTextureFromFile(Device.Get().Handle, Device.Get().ContextHandle, ExportDir + "tmp.dds",
out var resource, out var resourceView, 0, out var alphaMode);
// convert to obtain color data
using (var newTex = model.Export.convert.ConvertFromRaw3D(resourceView, origTex.Size, Format.R32G32B32A32_Float))
{
resourceView.Dispose();
resource.Dispose();
newColors = newTex.GetPixelColors(0, 0);
// only compare with red channel since some formats only store red
TestData.CompareColors(origColors, newColors, Color.Channel.R, 0.1f);
}
}
catch (Exception e)
{
errors += $"{format}: {e.Message}\n";
++numErrors;
}
}
if (errors.Length > 0)
{
throw new Exception($"directX compability failed for {numErrors}/{nFormats} formats:\n" + errors);
}
}
public void SingleImage()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "small.png");
model.Apply();
// look at the generated image
Assert.IsNotNull(model.Pipelines[0].Image);
var colors = model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip0);
TestData.CompareWithSmall(colors, Color.Channel.Rgb);
}
public void ExportLdrUnorm()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "small.bmp");
// set formula to srgb but export with ldr mode unorm
model.Pipelines[0].Color.Formula = "tosrgb(I0)";
model.Apply();
model.ExportPipelineImage(ExportDir + "unorm", "bmp", GliFormat.RGB8_UNORM);
TestData.CompareWithSmall(IO.LoadImage(ExportDir + "unorm.bmp"), Color.Channel.Rgb);
}
public void CropOverlayLayers()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "cubemap.dds");
models.Apply();
var dim = models.Images.Size;
var crop = new CropOverlay(models);
models.Overlay.Overlays.Add(crop);
// everything should be the same
crop.Start = Float3.Zero;
crop.End = Float3.One;
crop.Layer = -1;
crop.IsEnabled = true;
Assert.IsFalse(crop.HasWork);
crop.Layer = 1;
var refColors = new Color[][]
{
models.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Layer0),
models.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Layer1),
models.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Layer2),
models.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Layer3),
models.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Layer4),
models.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Layer5),
};
// gray out all layers except layer 1
for (int layer = 0; layer < 6; ++layer)
{
if (layer == 1)
{
continue;
}
for (var index = 0; index < refColors[layer].Length; index++)
{
refColors[layer][index] = refColors[layer][index].Scale(0.5f, Color.Channel.Rgb);
}
}
TestData.CompareColors(refColors[0], GetColorAfterExport(models, 0));
TestData.CompareColors(refColors[1], GetColorAfterExport(models, 1));
TestData.CompareColors(refColors[2], GetColorAfterExport(models, 2));
TestData.CompareColors(refColors[3], GetColorAfterExport(models, 3));
TestData.CompareColors(refColors[4], GetColorAfterExport(models, 4));
TestData.CompareColors(refColors[5], GetColorAfterExport(models, 5));
}
public void TriangleFastFilterEnergyConserve()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "checkers.dds");
models.Pipelines[0].Color.Formula = "I0 * RGB(1, 1, 0)";
models.Images.DeleteMipmaps();
models.Images.GenerateMipmaps(models.Scaling);
models.Scaling.Minify = ScalingModel.MinifyFilters.Triangle;
models.Pipelines[0].RecomputeMipmaps = true;
models.Apply();
TestEnergyConserve(models);
}
public void ExportOverlayed()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "sphere.png");
models.Apply();
// 31 by 31 image
Assert.AreEqual(models.Images.Size.X, 31);
Assert.AreEqual(models.Images.Size.Y, 31);
var boxes = new BoxOverlay(models);
models.Overlay.Overlays.Add(boxes);
var dim = models.Images.Size;
boxes.Boxes.Add(new BoxOverlay.Box
{
Start = new Size2(18, 11).ToCoords(dim.XY),
End = new Size2(24, 20).ToCoords(dim.XY),
Border = 1,
Color = new Color(1.0f, 1.0f, 0.0f)
});
boxes.Boxes.Add(new BoxOverlay.Box
{
Start = new Size2(7, 9).ToCoords(dim.XY),
End = new Size2(15, 15).ToCoords(dim.XY),
Border = 2,
Color = new Color(1.0f, 0.0f, 0.0f)
});
Assert.IsTrue(boxes.HasWork);
Assert.IsNotNull(models.Overlay.Overlay);
var filename = ExportTest.ExportDir + "overlayed";
// create export directory
ExportTest.Init(null);
models.Export.Export(new ExportDescription(models.Pipelines[0].Image, filename, "png")
{
FileFormat = GliFormat.RGBA8_SRGB,
Overlay = models.Overlay.Overlay
});
var imported = IO.LoadImageTexture(filename + ".png");
var reference = IO.LoadImageTexture(TestData.Directory + "sphere_with_overlay.png");
TestData.CompareColors(reference.GetPixelColors(LayerMipmapSlice.Mip0), imported.GetPixelColors(LayerMipmapSlice.Mip0), Color.Channel.Rgba, 0.0f);
}
public void BlurFilter()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "sphere.png");
model.Filter.AddFilter(model.CreateFilter("filter/blur.hlsl"));
model.Apply();
var colors = model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip0);
// compare with refence image
var refColors = TestData.GetColors("sphere_blur.png");
TestData.CompareColors(refColors, colors);
}
public void MedianFilter()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "sphere_salt.png");
model.Filter.AddFilter(model.CreateFilter("filter/median.hlsl"));
model.Apply();
var colors = model.Pipelines[0].Image.GetPixelColors(0, 0);
// compare with refence image
var refColors = TestData.GetColors("sphere_median.png");
TestData.CompareColors(refColors, colors);
}
public void TriangleSlowFilterEnergyConserve()
{
var models = new Models(1);
// this filter is actually not 100% energy conservant (i.e. if going from 3x3 to 1x1)
models.AddImageFromFile(TestData.Directory + "checkers3x7.png");
models.Pipelines[0].Color.Formula = "I0 * RGB(1, 1, 0)";
models.Pipelines[0].RecomputeMipmaps = true;
models.Scaling.Minify = ScalingModel.MinifyFilters.Triangle;
models.Images.GenerateMipmaps(models.Scaling);
models.Apply();
TestEnergyConserve(models);
}
public void Retarget()
{
// add filter (will be added as 2D)
Assert.AreEqual(FilterLoader.TargetType.Tex2D, filters.CurrentTarget);
// load gamma filter and set factor to 4.0
var gamma = models.CreateFilter("filter/gamma.hlsl");
bool found = false;
foreach (var param in gamma.Parameters)
{
if (param.GetBase().Name == "Factor")
{
param.GetFloatModel().Value = 4.0f;
found = true;
}
}
Assert.IsTrue(found);
models.Filter.AddFilter(gamma);
// add 3d image which should trigger retarget
models.AddImageFromFile(TestData.Directory + "checkers3d.dds");
Assert.AreEqual(FilterLoader.TargetType.Tex3D, filters.CurrentTarget);
Assert.AreEqual(1, filters.Filter.Count);
// verify that parameter is still set
found = false;
foreach (var param in filters.Filter[0].Parameters)
{
if (param.GetBase().Name == "Factor")
{
Assert.AreEqual(4.0f, param.GetFloatModel().Value);
found = true;
}
}
Assert.IsTrue(found);
}
public void NormalizeFunctionResults()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "pixel.png");
var eq = models.Pipelines[0].Alpha;
eq.Formula = "Red(normalize(RGB(1,0,0)))";
TestFor(models, 1.0f);
eq.Formula = "Red(normalize(RGB(-1,0,0)))";
TestFor(models, -1.0f);
eq.Formula = "Red(normalize(0))";
TestFor(models, float.NaN);
}
public void PowFunctionResults()
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "pixel.png");
Assert.AreEqual(1, models.Images.Size.X);
Assert.AreEqual(1, models.Images.Size.Y);
var eq = models.Pipelines[0].Alpha;
// X > 0, Y > 0
eq.Formula = "2^2";
TestFor(models, 4.0f);
// X > 0, Y < 0
eq.Formula = "2^-2";
TestFor(models, 0.25f);
// X > 0, Y == 0
eq.Formula = "12^0";
TestFor(models, 1.0f);
// X == 0, Y > 0
eq.Formula = "0^1.2";
TestFor(models, 0.0f);
// X == 0, Y < 0
eq.Formula = "0^-1.2";
TestFor(models, float.PositiveInfinity);
// X == 0, Y == 0
eq.Formula = "0^0";
TestFor(models, float.NaN);
// X < 0, Y even
eq.Formula = "(-2)^2";
TestFor(models, 4.0f);
// X < 0, Y odd
eq.Formula = "(-2)^3";
TestFor(models, -8.0f);
// X < 0, Y fractional
eq.Formula = "(-2)^1.00001";
TestFor(models, float.NaN);
}
public void NanImage() // using an image that has nans
{
var models = new Models(1);
models.AddImageFromFile(TestData.Directory + "sphere_nan.dds");
models.Apply();
// get statistics
var stats = models.GetStatistics(models.Pipelines[0].Image);
// calculate (alpha) statistics by hand
var cpuStats = CalcCpuStats(models.Pipelines[0].Image.GetPixelColors(0, 0));
Assert.AreEqual(cpuStats.Min, stats.Alpha.Min);
Assert.AreEqual(cpuStats.Max, stats.Alpha.Max);
Assert.AreEqual(cpuStats.Avg, stats.Alpha.Avg, 0.01f);
}
public void Scale()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "small.png");
model.Apply();
Assert.IsFalse(model.Pipelines[0].HasChanges);
model.Images.ScaleImages(new Size3(5, 6), model.Scaling);
Assert.IsTrue(model.Pipelines[0].HasChanges);
model.Apply();
Assert.AreEqual(5, model.Images.Size.Width);
Assert.AreEqual(6, model.Images.Size.Height);
Assert.AreEqual(5, model.Pipelines[0].Image.Size.Width);
Assert.AreEqual(6, model.Pipelines[0].Image.Size.Height);
}
public void BlurFilter()
{
var model = new Models(1);
model.AddImageFromFile(TestData.Directory + "sphere.png");
model.Filter.AddFilter(model.CreateFilter("filter/blur.hlsl"));
var variance = model.Filter.Filter[0].Parameters.First(param => param.GetBase().Name == "Variance");
Assert.IsNotNull(variance);
variance.GetFloatModel().Value = 36.23f;
model.Apply();
var colors = model.Pipelines[0].Image.GetPixelColors(LayerMipmapSlice.Mip0);
// compare with refence image
var refColors = TestData.GetColors("sphere_blur.png");
TestData.CompareColors(refColors, colors);
}
