/// <summary>
/// renders the ssim structure into a texture
/// </summary>
public void GetStructureTexture(ITexture image1, ITexture image2, ITexture dst, Settings s)
{
Debug.Assert(image1.HasSameDimensions(image2));
Debug.Assert(image1.HasSameDimensions(dst));
var cache = GetCache(image1);
var structTex = cache.GetTexture();
using (var data = new ImagesCorrelationStats(cache))
{
foreach (var lm in image1.LayerMipmap.Range)
{
RenderImagesCorrelation(image1, image2, data, lm);
RenderStructure(data, structTex, lm);
if (!s.Multiscale)
{
RenderRedToRgba(structTex, dst, lm);
}
}
if (s.Multiscale)
{
foreach (var lm in image1.LayerMipmap.Range)
{
RenderContrastStructureMultiscale(structTex, lm);
RenderRedToRgba(structTex, dst, lm);
}
}
}
cache.StoreTexture(structTex);
}
private void RenderSSIM(ITexture luminance, ITexture contrast, ITexture structure, ITexture dst, LayerMipmapSlice lm)
{
Debug.Assert(luminance.HasSameDimensions(contrast));
Debug.Assert(luminance.HasSameDimensions(structure));
Debug.Assert(luminance.HasSameDimensions(dst));
ssimShader.Run(new[] { luminance, contrast, structure }, dst, lm, models.SharedModel.Upload);
}
private void RenderRedToRgba(ITexture src, ITexture dst, LayerMipmapSlice lm)
{
Debug.Assert(src.HasSameDimensions(dst));
Debug.Assert(src.Format == Format.R32_Float);
Debug.Assert(dst.Format == Format.R32G32B32A32_Float);
redToRgbaTransform.Run(src, dst, lm, models.SharedModel.Upload);
}
public Stats GetStats(ITexture image1, ITexture image2, LayerMipmapRange lmRange, Settings s)
{
Debug.Assert(image1.HasSameDimensions(image2));
Debug.Assert(lmRange.IsSingleMipmap);
var cache = GetCache(image1);
var lumTex = cache.GetTexture();
var contTex = cache.GetTexture();
var strucTex = cache.GetTexture();
var ssimTex = cache.GetTexture();
using (var data = new ImagesCorrelationStats(cache))
{
if (!s.Multiscale)
{
foreach (var lm in image1.LayerMipmap.RangeOf(lmRange))
{
// determine expected value, variance, correlation
RenderImagesCorrelation(image1, image2, data, lm);
// calc the three components
RenderLuminance(data, lumTex, lm);
RenderContrast(data, contTex, lm);
RenderStructure(data, strucTex, lm);
// build ssim
//RenderSSIM(data, ssimTex, lm);
RenderSSIM(lumTex, strucTex, contTex, ssimTex, lm);
}
}
else // multiscale
{
int endMipmap = Math.Min(lmRange.Mipmap + 5, image1.NumMipmaps);
for (int curMip = lmRange.Mipmap; curMip < endMipmap; ++curMip)
{
foreach (var lm in image1.LayerMipmap.RangeOf(new LayerMipmapRange(lmRange.Layer, curMip)))
{
// determine expected value, variance, correlation
RenderImagesCorrelation(image1, image2, data, lm);
// calc components
if (curMip == endMipmap - 1) // luminance only for last mipmap
{
RenderLuminance(data, lumTex, lm);
}
RenderContrast(data, contTex, lm);
RenderStructure(data, strucTex, lm);
}
}
// combine values of different scales to compute ssim
foreach (var lm in image1.LayerMipmap.RangeOf(lmRange))
{
// determine appropriate scale scores
RenderLuminanceMultiscale(lumTex, lm);
RenderContrastStructureMultiscale(contTex, lm);
RenderContrastStructureMultiscale(strucTex, lm);
// build ssim
RenderSSIM(lumTex, strucTex, contTex, ssimTex, lm);
}
}
}
var stats = new Stats
{
Luminance = GetAveragedValue(lumTex, lmRange, s.ExcludeBorders),
Contrast = GetAveragedValue(contTex, lmRange, s.ExcludeBorders),
Structure = GetAveragedValue(strucTex, lmRange, s.ExcludeBorders),
SSIM = GetAveragedValue(ssimTex, lmRange, s.ExcludeBorders)
};
cache.StoreTexture(lumTex);
cache.StoreTexture(contTex);
cache.StoreTexture(strucTex);
cache.StoreTexture(ssimTex);
return(stats);
}
/// <summary>
/// converts the texture into another format and performs cropping if requested
/// </summary>
/// <param name="texture">source texture</param>
/// <param name="dstFormat">destination format</param>
/// <param name="srcLm">layer/mipmap to export</param>
/// <param name="multiplier">rgb channels will be multiplied by this value</param>
/// <param name="crop">indicates if the image should be cropped, only works with 1 mipmap to export</param>
/// <param name="offset">if crop: offset in source image</param>
/// <param name="size">if crop: size of the destination image</param>
/// <param name="align">if nonzero: texture width will be aligned to this (rounded down)</param>
/// <param name="scaling">required for regenerating mipmaps after cropping.</param>
/// <param name="overlay">overlay</param>
/// <param name="scale">scales the destination image by this factor</param>
/// <returns></returns>
public ITexture Convert(ITexture texture, SharpDX.DXGI.Format dstFormat, LayerMipmapRange srcLm, float multiplier, bool crop,
Size3 offset, Size3 size, Size3 align, ScalingModel scaling, ITexture overlay = null, int scale = 1)
{
Debug.Assert(ImageFormat.IsSupported(dstFormat));
Debug.Assert(ImageFormat.IsSupported(texture.Format));
Debug.Assert(overlay == null || texture.HasSameDimensions(overlay));
Debug.Assert(scale >= 1);
// set width, height mipmap
int nMipmaps = srcLm.IsSingleMipmap ? 1: texture.NumMipmaps;
int nLayer = srcLm.IsSingleLayer ? 1 : texture.NumLayers;
// set correct width, height, offsets
if (!crop)
{
size = texture.Size.GetMip(srcLm.FirstMipmap);
offset = Size3.Zero;
}
if (scale != 1)
{
size.X *= scale;
size.Y *= scale;
if (texture.Is3D)
{
size.Z *= scale;
}
offset.X *= scale;
offset.Y *= scale;
if (texture.Is3D)
{
offset.Z *= scale;
}
}
// adjust alignments
for (int i = 0; i < 3; ++i)
{
if (align[i] != 0)
{
if (size[i] % align[i] != 0)
{
if (size[i] < align[i])
{
throw new Exception($"image needs to be aligned to {align[i]} but one axis is only {size[i]}. Axis should be at least {align[i]}");
}
crop = true;
var remainder = size[i] % align[i];
offset[i] = offset[i] + remainder / 2;
size[i] = size[i] - remainder;
}
}
}
bool recomputeMips = nMipmaps > 1 && (crop || scale != 1);
if (recomputeMips)
{
// number of mipmaps might have changed
nMipmaps = size.MaxMipLevels;
recomputeMips = nMipmaps > 1;
}
var res = texture.Create(new LayerMipmapCount(nLayer, nMipmaps), size, dstFormat, false);
var dev = DirectX.Device.Get();
quad.Bind(texture.Is3D);
if (texture.Is3D)
{
dev.Pixel.Set(convert3D.Pixel);
}
else
{
dev.Pixel.Set(convert2D.Pixel);
}
dev.Pixel.SetShaderResource(0, texture.View);
if (overlay != null)
{
dev.Pixel.SetShaderResource(1, overlay.View);
}
else
{
dev.Pixel.SetShaderResource(1, null);
}
foreach (var dstLm in res.LayerMipmap.Range)
{
cbuffer.SetData(new LayerLevelOffsetData
{
Layer = dstLm.Layer + srcLm.FirstLayer + offset.Z,
Level = dstLm.Mipmap + srcLm.FirstMipmap,
Xoffset = offset.X,
Yoffset = offset.Y,
Multiplier = multiplier,
UseOverlay = overlay != null ? 1 : 0,
Scale = scale
});
var dim = res.Size.GetMip(dstLm.Mipmap);
dev.Pixel.SetConstantBuffer(0, cbuffer.Handle);
dev.OutputMerger.SetRenderTargets(res.GetRtView(dstLm));
dev.SetViewScissors(dim.Width, dim.Height);
dev.DrawFullscreenTriangle(dim.Depth);
if (recomputeMips && dstLm.Mipmap > 0)
{
break; // only write most detailed mipmap
}
}
// remove bindings
dev.Pixel.SetShaderResource(0, null);
dev.Pixel.SetShaderResource(1, null);
dev.OutputMerger.SetRenderTargets((RenderTargetView)null);
quad.Unbind();
if (recomputeMips)
{
scaling.WriteMipmaps(res);
}
return(res);
}
public void Run(ITexture src, ITexture dst, LayerMipmapSlice lm, UploadBuffer buffer, ITextureCache cache)
{
Debug.Assert(src.HasSameDimensions(dst));
Debug.Assert(cache.IsCompatibleWith(src));
Debug.Assert(lm.IsIn(src.LayerMipmap));
var srcSize = src.Size.GetMip(lm.Mipmap);
var dev = Device.Get();
dev.Compute.Set(src.Is3D ? Shader3D.Compute : Shader.Compute);
var builder = src.Is3D ? ShaderBuilder.Builder3D : ShaderBuilder.Builder2D;
// execute x
buffer.SetData(new BufferData
{
Size = srcSize,
Direction = new Size3(1, 0, 0),
Layer = lm.Layer
});
dev.Compute.SetConstantBuffer(0, buffer.Handle);
dev.Compute.SetShaderResource(0, src.GetSrView(lm));
var tmp1 = cache.GetTexture();
ITexture tmp2 = null;
dev.Compute.SetUnorderedAccessView(0, tmp1.GetUaView(lm.Mipmap));
dev.Dispatch(
Utility.Utility.DivideRoundUp(srcSize.Width, builder.LocalSizeX),
Utility.Utility.DivideRoundUp(srcSize.Height, builder.LocalSizeY),
Utility.Utility.DivideRoundUp(srcSize.Depth, builder.LocalSizeZ)
);
UnbindResources(dev);
// execute y
buffer.SetData(new BufferData
{
Size = srcSize,
Direction = new Size3(0, 1, 0),
Layer = lm.Layer
});
dev.Compute.SetConstantBuffer(0, buffer.Handle);
dev.Compute.SetShaderResource(0, tmp1.GetSrView(lm));
if (src.Is3D)
{
tmp2 = cache.GetTexture();
dev.Compute.SetUnorderedAccessView(0, tmp2.GetUaView(lm.Mipmap));
dev.Dispatch(
Utility.Utility.DivideRoundUp(srcSize.Width, builder.LocalSizeX),
Utility.Utility.DivideRoundUp(srcSize.Height, builder.LocalSizeY),
Utility.Utility.DivideRoundUp(srcSize.Depth, builder.LocalSizeZ)
);
UnbindResources(dev);
// execute z
buffer.SetData(new BufferData
{
Size = srcSize,
Direction = new Size3(0, 0, 1),
Layer = lm.Layer
});
dev.Compute.SetConstantBuffer(0, buffer.Handle);
dev.Compute.SetShaderResource(0, tmp2.GetSrView(lm));
}
// bind final target
dev.Compute.SetUnorderedAccessView(0, dst.GetUaView(lm.Mipmap));
dev.Dispatch(
Utility.Utility.DivideRoundUp(srcSize.Width, builder.LocalSizeX),
Utility.Utility.DivideRoundUp(srcSize.Height, builder.LocalSizeY),
Utility.Utility.DivideRoundUp(srcSize.Depth, builder.LocalSizeZ)
);
UnbindResources(dev);
cache.StoreTexture(tmp1);
if (tmp2 != null)
{
cache.StoreTexture(tmp2);
}
}
public bool IsCompatibleWith(ITexture tex)
{
Debug.Assert(tex != null);
return(templateTex.HasSameDimensions(tex));
}
