/// <summary>
/// Forward Laplacian pyramid transform.
/// </summary>
/// <param name="data">Gaussian pyramid</param>
/// <returns>Pyramid</returns>
public float[][,] Forward(float[][,] data)
{
int nlev = data.Length;
float[][,] lapl = new float[nlev][, ];
for (int i = 1; i < nlev; i++)
{
lapl[i - 1] = GaussianPyramidTransform.sub(data[i - 1], GaussianPyramidTransform.upsample(data[i], this.radius));
}
lapl[nlev - 1] = data[nlev - 1];
return(lapl);
}
// **************************************************
// Laplacian Pyramid Transform
// **************************************************
// ORIGINALS: Burt, P., and Adelson, E. H.
// IEEE Transactions on Communication, COM-31:532-540
// (1983).
// Designed by Valery Asiryan (c), 2015-2020
// Moscow, Russia.
// **************************************************
/// <summary>
/// Forward Laplacian pyramid transform.
/// </summary>
/// <param name="data">Matrix</param>
/// <returns>Pyramid</returns>
public float[][,] Forward(float[,] data)
{
int r = data.GetLength(0), c = data.GetLength(1);
int nlev = (int)Math.Min((Math.Log(Math.Min(r, c)) / Math.Log(2)), levels);
float[][,] lapl = new float[nlev][, ];
float[,] I, J = data;
for (int i = 0; i < nlev - 1; i++)
{
I = GaussianPyramidTransform.downsample(J, this.radius);
lapl[i] = GaussianPyramidTransform.sub(J, GaussianPyramidTransform.upsample(I, this.radius));
J = I;
}
lapl[nlev - 1] = J;
return(lapl);
}
/// <summary>
/// Forward Laplacian pyramid transform.
/// </summary>
/// <param name="data">Array</param>
/// <returns>Pyramid</returns>
public Complex32[][] Forward(Complex32[] data)
{
int r = data.Length;
int nlev = (int)Math.Min((Math.Log(r) / Math.Log(2)), levels);
Complex32[][] lapl = new Complex32[nlev][];
Complex32[] I, J = data;
for (int i = 0; i < nlev - 1; i++)
{
I = GaussianPyramidTransform.downsample(J, this.radius);
lapl[i] = GaussianPyramidTransform.sub(J, GaussianPyramidTransform.upsample(I, this.radius));
J = I;
}
lapl[nlev - 1] = J;
return(lapl);
}
/// <summary>
/// Local laplacian filter.
/// </summary>
/// <param name="input">Input data</param>
/// <param name="radius">Radius</param>
/// <param name="sigma">Sigma</param>
/// <param name="factor">Factor</param>
/// <param name="n">Number of steps</param>
/// <param name="levels">Levels</param>
/// <returns>Output data</returns>
internal static void llfilter(float[] input, int radius, float sigma, float factor, int n, int levels)
{
// exception
if (factor == 0)
{
return;
}
// data
int height = input.GetLength(0);
int y, level, length = 256;
float step = 1.0f / n;
float min = 0.0f, max = 1.0f;
// pyramids
int n_levels = (int)Math.Min((Math.Log(height) / Math.Log(2)), levels);
LaplacianPyramidTransform lpt = new LaplacianPyramidTransform(n_levels, radius);
GaussianPyramidTransform gpt = new GaussianPyramidTransform(n_levels, radius);
float[][] input_gaussian_pyr = gpt.Forward(input);
float[][] output_laplace_pyr = lpt.Forward(input_gaussian_pyr);
float[][] temp_laplace_pyr;
float[] I_temp, I_gaus, I_outp;
float[] T;
// do job
for (float i = min; i <= max; i += step)
{
height = input.GetLength(0);
I_temp = new float[height];
T = Rem(sigma, factor, i, length);
// remapping function
for (y = 0; y < height; y++)
{
I_temp[y] = T[Maths.Byte(input[y] * (length - 1))];
}
temp_laplace_pyr = lpt.Forward(I_temp);
T = Rec(i, step, length);
// pyramid reconstruction
for (level = 0; level < n_levels; level++)
{
I_gaus = input_gaussian_pyr[level];
I_temp = temp_laplace_pyr[level];
I_outp = output_laplace_pyr[level];
height = I_outp.GetLength(0);
for (y = 0; y < height; y++)
{
I_outp[y] += T[Maths.Byte(I_gaus[y] * (length - 1))] * I_temp[y];
}
output_laplace_pyr[level] = I_outp;
}
}
// backward transform
I_outp = lpt.Backward(output_laplace_pyr);
height = input.GetLength(0);
for (y = 0; y < height; y++)
{
input[y] = I_outp[y];
}
return;
}
