/// <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); }