/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
float s = (Intensity.log05 / (float)Math.Log(0.5 - value2gamma(shadows)));
float l = (Intensity.log05 / (float)Math.Log(0.5 + value2gamma(lights)));
this.values = Intensity.LogStretch(s, l, 256);
}
/// <summary>
/// Implements the log-contrast correction.
/// </summary>
/// <param name="x">Brightness</param>
/// <param name="power">Power</param>
/// <returns>float precision floating point number</returns>
public static float LogContrast(float x, float power)
{
if (x <= 0.5)
{
return((float)Intensity.LogPow(x * 2, power) * 0.5f);
}
return(1.0f - (float)Intensity.LogPow((1 - x) * 2, power) * 0.5f);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="max">Maximum value</param>
/// <param name="min">Minimum value</param>
/// <param name="length">Length</param>
/// <returns>Array</returns>
public static float[] Equalize(float min, float max, int length)
{
float[] table = new float[length];
for (int x = 0; x < length; x++)
{
table[x] = Intensity.Equalize(x / (float)length, min, max);
}
return(table);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="xmax">Maximum value</param>
/// <param name="xmin">Minimum value</param>
/// <param name="delta">Delta</param>
/// <param name="length">Length</param>
/// <returns>Array</returns>
public static float[] Linear(float xmax, float xmin, float delta, int length)
{
float[] table = new float[length];
for (int x = 0; x < length; x++)
{
table[x] = Intensity.Linear(x / (float)length, xmax, xmin, delta);
}
return(table);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="s">Shadows</param>
/// <param name="l">Highlights</param>
/// <param name="length">Length</param>
/// <returns>Matrix</returns>
public static float[,] LogStretch(float s, float l, int length)
{
float[,] table = new float[length, length];
float w, v;
int x, y;
for (x = 0; x < length; x++)
{
w = x / (float)length;
for (y = 0; y < length; y++)
{
v = y / (float)length;
table[x, y] = Intensity.LogStretch(w, v, s, l);
}
}
return(table);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="nbase">Logarithm base</param>
/// <param name="a">Factor (0, 1]</param>
/// <param name="b">Offset (0, 1]</param>
/// <param name="length">Length</param>
/// <returns>Matrix</returns>
public static float[,] SingleScaleRetinex(float nbase, float a, float b, int length)
{
float[,] table = new float[length, length];
float w, v;
int x, y;
for (x = 0; x < length; x++)
{
w = x / (float)length;
for (y = 0; y < length; y++)
{
v = y / (float)length;
table[x, y] = Intensity.SingleScaleRetinex(w, v, nbase, a, b);
}
}
return(table);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="a">Factor [-1, 1]</param>
/// <param name="length">Length</param>
/// <returns>Matrix</returns>
public static float[,] SAUCE(float a, int length)
{
float[,] table = new float[length, length];
float w, v;
int x, y;
for (x = 0; x < length; x++)
{
w = x / (float)length;
for (y = 0; y < length; y++)
{
v = y / (float)length;
table[x, y] = Intensity.SAUCE(w, v, a);
}
}
return(table);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="a">Factor (0, 1]</param>
/// <param name="b">Offset (0, 1]</param>
/// <param name="length">Length</param>
/// <returns>Matrix</returns>
public static float[,] LocalContrastInversion(float a, float b, int length)
{
float[,] table = new float[length, length];
float w, v;
int x, y;
for (x = 0; x < length; x++)
{
w = x / (float)length;
for (y = 0; y < length; y++)
{
v = y / (float)length;
table[x, y] = Intensity.LocalContrastInversion(w, v, a, b);
}
}
return(table);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="difference">Difference [0, 1]</param>
/// <param name="length">Length</param>
/// <returns>Matrix</returns>
public static float[,] Bradley(float difference, int length)
{
float[,] table = new float[length, length];
float w, v;
int x, y;
for (x = 0; x < length; x++)
{
w = x / (float)length;
for (y = 0; y < length; y++)
{
v = y / (float)length;
table[x, y] = Intensity.Bradley(w, v, difference);
}
}
return(table);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="a">Contrast [-1, 1]</param>
/// <param name="b">Offset [-1, 1]</param>
/// <param name="length">Length</param>
/// <returns>Matrix</returns>
public static float[,] KsiContrastEnchancement(float a, float b, int length)
{
float[,] table = new float[length, length];
float w, v;
int x, y;
for (x = 0; x < length; x++)
{
w = x / (float)length;
for (y = 0; y < length; y++)
{
v = y / (float)length;
table[x, y] = Intensity.KsiContrastEnchancement(w, v, a, b);
}
}
return(table);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="input">Input values</param>
/// <param name="output">Output values</param>
/// <param name="length">Length</param>
/// <returns>Array</returns>
public static float[] Levels(RangeFloat input, RangeFloat output, int length)
{
return(Intensity.Levels(input.Min, input.Max, output.Min, output.Max, length));
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Equalize(range.Min, range.Max, 256);
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="range">Pair of numbers Max и Min</param>
/// <param name="delta">Delta</param>
/// <param name="length">Length</param>
/// <returns>Array</returns>
public static float[] Linear(RangeFloat range, float delta, int length)
{
return(Intensity.Linear(range.Max, range.Min, delta, length));
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Levels(input, output, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.KsiContrastEnchancement(this.a, this.b, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Linear(range, delta / 2.0f, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Bradley(this.difference, 256);
}
/// <summary>
/// Implements the logarithmic stretch algorithm.
/// </summary>
/// <param name="x">Brightness</param>
/// <param name="mu">Filter brightness</param>
/// <param name="s">Shadows</param>
/// <param name="l">Highlights</param>
/// <returns>float precision floating point number</returns>
public static float LogStretch(float x, float mu, float s, float l)
{
return(Intensity.LogPow(x, Maths.Range(Intensity.log05 / (float)Math.Log(mu), s, l)));
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.LocalContrastEnhancement(this.contrast, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.LogContrast(1 + this.contrast, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Shift(this.offset, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Bin(this.threshold, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.SingleScaleRetinex(this.nbase, this.a, this.b, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Cos(delta / 2.0f, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Add(this.brightness / 2.0f, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Gamma(this.g, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.HomomorphicEnhancement(this.a, this.b, 256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Add(this.transparency, 256);
}
/// <summary>
/// Initializes the channels inversion filter.
/// </summary>
public InvertChannels(Space space)
{
this.values = Intensity.Invert(256);
}
/// <summary>
/// Implements filter rebuilding.
/// </summary>
protected override void Rebuild()
{
this.values = Intensity.Quantize(this.levels, 256);
}
