/// <summary>
/// Apply filter.
/// </summary>
/// <param name="bmData">Bitmap data</param>
/// <param name="bmSrc">Bitmap data</param>
private unsafe void ApplyHSL(BitmapData bmData, BitmapData bmSrc)
{
byte *p = (byte *)bmData.Scan0.ToPointer(), pSrc = (byte *)bmSrc.Scan0.ToPointer();
int width = bmData.Width, height = bmData.Height, stride = bmData.Stride;
float length = values.GetLength(0) - 1;
Parallel.For(0, height, j =>
{
HSL lumI; HSL lumIx; RGB rgb;
int i, k, k1, k2, jstride = j * stride;
for (i = 0; i < width; i++)
{
k = jstride + i * 4; k1 = k + 1; k2 = k + 2;
lumI = HSL.FromRGB(p[k2], p[k1], p[k]);
lumIx = HSL.FromRGB(pSrc[k2], pSrc[k1], pSrc[k]);
lumI.Lightness = this.values[(int)(lumI.Lightness * length), (int)(lumIx.Lightness * length)];
rgb = lumI.ToRGB;
p[k2] = rgb.Red; p[k1] = rgb.Green; p[k] = rgb.Blue;
}
}
);
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="bmData">Bitmap data</param>
private unsafe void ApplyHSL(BitmapData bmData)
{
byte *p = (byte *)bmData.Scan0.ToPointer();
int width = bmData.Width, height = bmData.Height, stride = bmData.Stride;
float length = values.Length - 1;
Parallel.For(0, height, y =>
{
int x, ystride, k;
HSL hsl; RGB rgb;
ystride = y * stride;
for (x = 0; x < width; x++)
{
k = ystride + x * 4;
hsl = HSL.FromRGB(p[k + 2], p[k + 1], p[k]);
hsl.Lightness = values[(int)(hsl.Lightness * length)];
rgb = hsl.ToRGB;
p[k + 2] = rgb.Red; p[k + 1] = rgb.Green; p[k] = rgb.Blue;
}
}
);
return;
}
public void fromYCbCr()
{
#region doc_ycbcr
// This example shows how to convert to and from various
// pixel representations. For example, let's say we start
// with a YCbCr pixel with the value (0.8, 0.2, 0.5):
YCbCr yCbCr = new YCbCr(y: 0.8f, cb: 0.2f, cr: 0.5f);
// The value of this pixel in RGB format would be:
RGB rgb = yCbCr.ToRGB(); // should be (255, 95, 255)
// The value of this pixel in HSL format would be:
HSL hsl = HSL.FromRGB(rgb); // should be (299, 0.99999994, 0.6862745)
// Note: we can also convert using casting:
RGB a = (RGB)yCbCr;
HSL b = (HSL)yCbCr;
#endregion
Assert.AreEqual(255, rgb.Red);
Assert.AreEqual(95, rgb.Green);
Assert.AreEqual(255, rgb.Blue);
Assert.AreEqual(255, rgb.Alpha);
Assert.AreEqual(299, hsl.Hue, 1);
Assert.AreEqual(0.99999994, hsl.Saturation, 1e-6);
Assert.AreEqual(0.6862745, hsl.Luminance, 1e-6);
Assert.AreEqual(0.8, yCbCr.Y, 1e-6);
Assert.AreEqual(0.2, yCbCr.Cb, 1e-6);
Assert.AreEqual(0.5, yCbCr.Cr, 1e-6);
Assert.AreEqual(rgb, a);
Assert.AreEqual(hsl, b);
}
public void fromRGB()
{
#region doc_rgb
// This example shows how to convert to and from various
// pixel representations. For example, let's say we start
// with a RGB pixel with the value (24, 250, 153):
RGB rgb = new RGB(red: 24, green: 250, blue: 153);
// The value of this pixel in HSL format would be:
HSL hsl = HSL.FromRGB(rgb); // should be (154, 0.9576271, 0.5372549)
// The value of this pixel in YCbCr format would be:
YCbCr yCbCr = YCbCr.FromRGB(rgb); // should be (0.671929836, -0.0406815559, -0.412097245)
// Note: we can also convert using casting:
HSL a = (HSL)rgb;
YCbCr b = (YCbCr)rgb;
#endregion
Assert.AreEqual(24, rgb.Red);
Assert.AreEqual(250, rgb.Green);
Assert.AreEqual(153, rgb.Blue);
Assert.AreEqual(255, rgb.Alpha);
Assert.AreEqual(154, hsl.Hue);
Assert.AreEqual(0.9576271, hsl.Saturation, 1e-6);
Assert.AreEqual(0.5372549, hsl.Luminance, 1e-6);
Assert.AreEqual(0.671929836, yCbCr.Y, 1e-6);
Assert.AreEqual(-0.0406815559, yCbCr.Cb, 1e-6);
Assert.AreEqual(-0.412097245, yCbCr.Cr, 1e-6);
Assert.AreEqual(hsl, a);
Assert.AreEqual(yCbCr, b);
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="bmData">Bitmap</param>
public unsafe void Apply(BitmapData bmData)
{
byte *p = (byte *)bmData.Scan0.ToPointer();
int width = bmData.Width, height = bmData.Height, stride = bmData.Stride;
Parallel.For(0, height, j =>
{
HSL hsl; RGB rgb;
int i, k, jstride = j * stride;
for (i = 0; i < width; i++)
{
k = jstride + i * 4;
hsl = HSL.FromRGB(p[k + 2], p[k + 1], p[k + 0]);
hsl.Hue = Maths.Scale(hsl.Hue + hue, 0, 360);
hsl.Saturation += saturation;
hsl.Lightness += lightness;
rgb = hsl.ToRGB;
p[k + 0] = rgb.Blue;
p[k + 1] = rgb.Green;
p[k + 2] = rgb.Red;
}
}
);
return;
}
protected unsafe override void ProcessFilter(UnmanagedImage image, Rectangle rect)
{
int num = System.Drawing.Image.GetPixelFormatSize(image.PixelFormat) / 8;
int left = rect.Left;
int top = rect.Top;
int num2 = left + rect.Width;
int num3 = top + rect.Height;
int num4 = image.Stride - rect.Width * num;
RGB rGB = new RGB();
HSL hSL = new HSL();
byte *ptr = (byte *)image.ImageData.ToPointer();
ptr += top * image.Stride + left * num;
for (int i = top; i < num3; i++)
{
int num5 = left;
while (num5 < num2)
{
rGB.Red = ptr[2];
rGB.Green = ptr[1];
rGB.Blue = *ptr;
HSL.FromRGB(rGB, hSL);
hSL.Hue = hue;
HSL.ToRGB(hSL, rGB);
ptr[2] = rGB.Red;
ptr[1] = rGB.Green;
*ptr = rGB.Blue;
num5++;
ptr += num;
}
ptr += num4;
}
}
protected override unsafe void ProcessFilter(UnmanagedImage image, Rectangle rect)
{
int num = Image.GetPixelFormatSize(image.PixelFormat) / 8;
int left = rect.Left;
int top = rect.Top;
int num4 = left + rect.Width;
int num5 = top + rect.Height;
int num6 = image.Stride - (rect.Width * num);
RGB rgb = new RGB();
HSL hsl = new HSL();
byte *numPtr = (byte *)(image.ImageData.ToPointer() + ((top * image.Stride) + (left * num)));
for (int i = top; i < num5; i++)
{
int num8 = left;
while (num8 < num4)
{
rgb.Red = numPtr[2];
rgb.Green = numPtr[1];
rgb.Blue = numPtr[0];
HSL.FromRGB(rgb, hsl);
hsl.Hue = this.hue;
HSL.ToRGB(hsl, rgb);
numPtr[2] = rgb.Red;
numPtr[1] = rgb.Green;
numPtr[0] = rgb.Blue;
num8++;
numPtr += num;
}
numPtr += num6;
}
}
public void AddBitmap(Bitmap anotherLayer)
{
for (int y = 0; y < OriginalImage.Height; y++)
{
for (int x = 0; x < OriginalImage.Width; x++)
{
var pixel = anotherLayer.GetPixel(x, y);
RGB rgb = new RGB(pixel);
Matrix[y, x] += HSL.FromRGB(rgb).Luminance;
}
}
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="bmData">Bitmap data</param>
public unsafe void Apply(BitmapData bmData)
{
byte *p = (byte *)bmData.Scan0.ToPointer();
int width = bmData.Width, height = bmData.Height, stride = bmData.Stride;
Parallel.For(0, height, j =>
{
HSL hsl; RGB rgb;
int i, k, jstride = j * stride;
for (i = 0; i < width; i++)
{
// This function modifies a given image in order to keep a specific hue
// (given too) and to desaturate the rest of the image. This procedure
// originates a image with black and white colormap, excluding the parts
// colored with that hue.
// Victor Martnez Cagigal, 23/02/2015
//
// Designed for UMapx.NET by Valery Asiryan, 2018.
k = jstride + i * 4;
// Convert to hsl:
hsl = HSL.FromRGB(p[k + 2], p[k + 1], p[k + 0]);
// Getting hue and saturation parameters:
float hue = hsl.Hue, saturation = hsl.Saturation;
// Applying filter:
if (min < max)
{
hsl.Saturation = (hue > min && hue < max) ? saturation : 0;
}
else
{
hsl.Saturation = ((hue > min && hue <= 360) || (hue < max && hue >= 0)) ? saturation : 0;
}
// Convert to rgb:
rgb = hsl.ToRGB;
p[k + 0] = rgb.Blue;
p[k + 1] = rgb.Green;
p[k + 2] = rgb.Red;
}
}
);
return;
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="bmData">Bitmap data</param>
/// <param name="bmMax">Bitmap data</param>
/// <param name="bmMin">Bitmap data</param>
private unsafe void ApplyHSL(BitmapData bmData, BitmapData bmMax, BitmapData bmMin)
{
byte *p = (byte *)bmData.Scan0.ToPointer();
byte *pMax = (byte *)bmMax.Scan0.ToPointer();
byte *pMin = (byte *)bmMin.Scan0.ToPointer();
int width = bmData.Width, height = bmData.Height, stride = bmData.Stride;
float required = 1.0f - this.contrast;
Parallel.For(0, height, j =>
{
HSL imag; HSL imax; HSL imin; RGB rgb;
int i, k, k1, k2, jstride = j * stride;
float mag, max, min;
float num1, num2, num3;
for (i = 0; i < width; i++)
{
k = jstride + i * 4; k1 = k + 1; k2 = k + 2;
imag = HSL.FromRGB(p[k2], p[k1], p[k]);
imax = HSL.FromRGB(pMax[k2], pMax[k1], pMax[k]);
imin = HSL.FromRGB(pMin[k2], pMin[k1], pMin[k]);
mag = imag.Lightness;
max = imax.Lightness;
min = imin.Lightness;
num1 = max - min;
if (num1 < required)
{
num2 = min + (required - num1) * min / (num1 - 1f);
min = Maths.Float(num2);
max = Maths.Float(num2 + required);
}
num1 = max - min;
num3 = mag - min;
if (num1 > 0)
{
imag.Lightness = num3 / num1;
rgb = imag.ToRGB;
p[k2] = rgb.Red; p[k1] = rgb.Green; p[k] = rgb.Blue;
}
}
}
);
}
public wColor SetLuminance(double LuminanceValue)
{
HSL hsl = HSL.FromRGB(new RGB((byte)WindColor.R, (byte)WindColor.G, (byte)WindColor.B));
hsl.Luminance = (float)LuminanceValue;
RGB rgb = hsl.ToRGB();
WindColor.R = rgb.Red;
WindColor.G = rgb.Green;
WindColor.B = rgb.Blue;
return(WindColor);
}
public ImagesNormalizer(Bitmap image)
{
OriginalImage = image;
Matrix = new float[image.Height, image.Width];
for (int y = 0; y < image.Height; y++)
{
for (int x = 0; x < image.Width; x++)
{
var pixel = image.GetPixel(x, y);
RGB rgb = new RGB(pixel);
Matrix[y, x] = HSL.FromRGB(rgb).Luminance;
}
}
}
internal static double GetSat(Matrix <double> outputValues, int subdivisions)
{
var satCounter = 0.0;
for (int i = 0; i < outputValues.RowCount; i++)
{
var rgb = new RGB((byte)(outputValues[i, 0] * 255), (byte)(outputValues[i, 1] * 255), (byte)(outputValues[i, 2] * 255));
var sat = HSL.FromRGB(rgb).Saturation;
satCounter += sat;
}
var meanSat = satCounter / outputValues.RowCount;
return(meanSat);
}
internal static double GetSatVar(Matrix <double> outputValues, int subdivisions)
{
List <double> sats = new List <double>();
for (int i = 0; i < outputValues.RowCount; i++)
{
var rgb = new RGB((byte)(outputValues[i, 0] * 255), (byte)(outputValues[i, 1] * 255), (byte)(outputValues[i, 2] * 255));
var sat = HSL.FromRGB(rgb).Saturation;
sats.Add(sat);
}
var variance = MathNet.Numerics.Statistics.Statistics.StandardDeviation(sats);
return(variance);
}
internal static double GetHue(Matrix <double> values, int subdivisions)
{
var hueCounter = 0;
for (int i = 0; i < values.RowCount; i++)
{
var rgb = new RGB((byte)(values[i, 0] * 255), (byte)(values[i, 1] * 255), (byte)(values[i, 2] * 255));
var hue = HSL.FromRGB(rgb).Hue;
hueCounter += hue;
}
var meanHue = hueCounter / values.RowCount;
return(meanHue);
}
internal static double GetHueDist(Matrix <double> values, Matrix <double> targets, int subdivisions)
{
var hueCounter = 0;
var valDist = new double[10];
var tarDist = new double[10];
var sizeRatio = targets.RowCount / values.RowCount;
for (int i = 0; i < values.RowCount; i++)
{
var rgb = new RGB((byte)(values[i, 0] * 255), (byte)(values[i, 1] * 255), (byte)(values[i, 2] * 255));
var hue = HSL.FromRGB(rgb).Hue;
int bucket = (int)hue / 36;
if (bucket > 9)
{
bucket = 9;
}
valDist[bucket]++;
// hueCounter += hue;
}
for (int i = 0; i < targets.RowCount; i++)
{
var rgb = new RGB((byte)(targets[i, 0] * 255), (byte)(targets[i, 1] * 255), (byte)(targets[i, 2] * 255));
var hue = HSL.FromRGB(rgb).Hue;
int bucket = (int)hue / 36;
if (bucket > 9)
{
bucket = 9;
}
tarDist[bucket]++;
//hueCounter += hue;
}
valDist = valDist.Select(x => x / (subdivisions * subdivisions)).ToArray();
tarDist = tarDist.Select(x => x / (sizeRatio * (subdivisions * subdivisions))).ToArray();
var distDist = FeatureDistance(valDist, tarDist);
return(distDist);
}
public mFilterHSL(wDomain HueValue, wDomain SaturationValue, wDomain LuminanceValue, bool isOut, Color fillColor)
{
Hue = HueValue;
Sat = SaturationValue;
Lum = LuminanceValue;
IsOut = isOut;
FillColor = fillColor;
BitmapType = mFilter.BitmapTypes.None;
Effect = new HSLFiltering(new Accord.IntRange((int)Hue.T0, (int)Hue.T1), new Accord.Range((float)Sat.T0, (float)Sat.T1), new Accord.Range((float)Lum.T0, (float)Lum.T1));
Effect.FillOutsideRange = IsOut;
Effect.FillColor = HSL.FromRGB(new RGB(FillColor));
filter = Effect;
}
public void addcouleur(Bitmap bm)
{
if (LstZone.Count == 0 || LstZone[LstZone.Count - 1].ID != -1 && col != null)
{
int w_i = bm.Width;
int h_i = bm.Height;
int w_c = imgReel.Width;
int h_c = imgReel.Height;
float ord = ((float)w_i * (float)((float)this.col[0] / (float)w_c));
float abs = ((float)h_i * (float)((float)this.col[1] / (float)h_c));
this.col = null;
int R = 0, G = 0, B = 0, A = 0;
int count = 0;
// Moyenne des pixels
for (int i = (int)(ord - 1); i < (int)(ord + 1); i++)
{
for (int j = (int)(abs - 1); j < (int)(abs + 1); j++)
{
count++;
Color c = bm.GetPixel(i, j);
R += c.R;
G += c.G;
B += c.B;
A += c.A;
}
}
RGB tmp = new RGB(((byte)(R / count)), ((byte)(G / count)), ((byte)(B / count)), ((byte)(A / count)));
HSL colo = HSL.FromRGB(tmp);
Logger.GlobalLogger.debug("Couleur ajoutée : " + tmp.ToString() + " HLS : " + colo.Hue + " " + colo.Luminance + " " + colo.Saturation);
HSLFiltering Filter = new HSLFiltering();
Filter.Hue = new IntRange((colo.Hue + 340) % 360, (colo.Hue + 20) % 360);
Filter.Saturation = new Range(0.6f, 1f);
Filter.Luminance = new Range(0.1f, 1f);
LstHslFiltering.Add(Filter);
PositionZone ZoneTmp = new PositionZone();
ZoneTmp.ID = -1;
LstZone.Add(ZoneTmp);
MessageBox.Show("Ajouter une zone de dépose avec le click milieu");
}
}
public static Color GetCorrected(Color color, Color background, string name)
{
if (cache.ContainsKey(name))
{
return(cache[name]);
}
if (color == default(Color))
{
var random = new Random();
color = Color.FromArgb(random.Next(0, 255), random.Next(0, 255), random.Next(0, 255));
}
var darkMode = IsDark(background);
var hsl = HSL.FromRGB(color.R, color.G, color.B);
// Color correction concept from: https://github.com/fourtf/chatterino
if (darkMode)
{
hsl.L = Math.Max(hsl.L, .5);
if (hsl.L < .6 && hsl.H > 196 && hsl.H < 300)
{
hsl.L += Math.Sin((hsl.H - 196) / (300 - 196) * Math.PI) * hsl.S * .4;
}
if (hsl.L < 0.8f && (hsl.H < 22 || hsl.H > 331))
{
hsl.L += (hsl.S * .1);
}
}
else
{
hsl.S = Math.Min(.4, hsl.S);
hsl.L = Math.Min(.5, hsl.L);
}
hsl.L = Math.Min(.95, hsl.L);
return(cache[name] = HSL.ToRGB(hsl));
}
public FundusFilterBase(Bitmap inputBitmap, bool storeAsColor)
{
this.storeAsColor = storeAsColor;
_inputBitmap = inputBitmap;
_inputLuminance = new float[_inputBitmap.Height, _inputBitmap.Width];
_inputHue = new int[_inputBitmap.Height, _inputBitmap.Width];
_inputSaturation = new float[_inputBitmap.Height, _inputBitmap.Width];
_outputLuminance = new float[_inputBitmap.Height, _inputBitmap.Width];
for (int x = 0; x < _inputBitmap.Width; x++)
{
for (int y = 0; y < _inputBitmap.Height; y++)
{
var pixelInMask = inputBitmap.GetPixel(x, y);
RGB rgbInMask = new RGB(pixelInMask);
HSL hslInMask = HSL.FromRGB(rgbInMask);
float luminanceOfPixelInMask = hslInMask.Luminance;
_inputLuminance[y, x] = luminanceOfPixelInMask;
_inputHue[y, x] = hslInMask.Hue;
_inputSaturation[y, x] = hslInMask.Saturation;
}
}
}
static void ForAllPixels(Bitmap image, Action <double[]> m)
{
/*
* //Slow (2x times) but safe
* for (int i = 0; i < image.Width; i++)
* for (int j = 0; j < image.Height; j++)
* m(HSL.FromRGB(new RGB(image.GetPixel(i, j))));
*/
using (var unmanagedImg = UnmanagedImage.FromManagedImage(image))
{
CheckSourceFormat(unmanagedImg.PixelFormat);
var pixelSize = (image.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4;
int pixelCnt = unmanagedImg.Height * unmanagedImg.Width;
unsafe
{
var p = (byte *)unmanagedImg.ImageData.ToPointer();
for (int pixels = 0; pixels < pixelCnt; pixels++, p += pixelSize)
{
var hsl = HSL.FromRGB(new RGB(p[RGB.R], p[RGB.G], p[RGB.B]));
m(new[] { hsl.Hue / 359.0, hsl.Saturation, hsl.Luminance });
}
}
}
}
/// <summary>
/// Gets an array of pixel luminances for a bitmap
/// </summary>
private static double[] GetLuminanceArray(Matrix <double> grayscales, int width)
{
//WHY DO I NEED WIDTH HERE?
var w = width;
var h = width;
var values = new double[w * h];
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
values[h * i + j] = grayscales[h * i + j, 0];
if (grayscales.ColumnCount == 3)
{
var rgb = new RGB((byte)(grayscales[i, 0] * 255), (byte)(grayscales[i, 1] * 255), (byte)(grayscales[i, 2] * 255));
var lum = HSL.FromRGB(rgb).Luminance;
values[h * i + j] = lum;
}
}
}
return(values);
}
protected override unsafe void ProcessFilter(UnmanagedImage image, Rectangle rect)
{
int num = (image.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4;
int left = rect.Left;
int top = rect.Top;
int num4 = left + rect.Width;
int num5 = top + rect.Height;
int num6 = image.Stride - (rect.Width * num);
RGB rgb = new RGB();
HSL hsl = new HSL();
byte *numPtr = (byte *)(image.ImageData.ToPointer() + ((top * image.Stride) + (left * num)));
for (int i = top; i < num5; i++)
{
int num8 = left;
while (num8 < num4)
{
bool flag = false;
rgb.Red = numPtr[2];
rgb.Green = numPtr[1];
rgb.Blue = numPtr[0];
HSL.FromRGB(rgb, hsl);
if ((((hsl.Saturation >= this.saturation.Min) && (hsl.Saturation <= this.saturation.Max)) && ((hsl.Luminance >= this.luminance.Min) && (hsl.Luminance <= this.luminance.Max))) && ((((this.hue.Min < this.hue.Max) && (hsl.Hue >= this.hue.Min)) && (hsl.Hue <= this.hue.Max)) || ((this.hue.Min > this.hue.Max) && ((hsl.Hue >= this.hue.Min) || (hsl.Hue <= this.hue.Max)))))
{
if (!this.fillOutsideRange)
{
if (this.updateH)
{
hsl.Hue = this.fillH;
}
if (this.updateS)
{
hsl.Saturation = this.fillS;
}
if (this.updateL)
{
hsl.Luminance = this.fillL;
}
flag = true;
}
}
else if (this.fillOutsideRange)
{
if (this.updateH)
{
hsl.Hue = this.fillH;
}
if (this.updateS)
{
hsl.Saturation = this.fillS;
}
if (this.updateL)
{
hsl.Luminance = this.fillL;
}
flag = true;
}
if (flag)
{
HSL.ToRGB(hsl, rgb);
numPtr[2] = rgb.Red;
numPtr[1] = rgb.Green;
numPtr[0] = rgb.Blue;
}
num8++;
numPtr += num;
}
numPtr += num6;
}
}
private void videoSourcePlayer1_NewFrame(object sender, ref Bitmap image)
{
lock (this)
{
//copy input image
using (Bitmap hsl = (Bitmap)image.Clone())
{
//filter by HSL
HSLFiltering filterHSL = new HSLFiltering();
// set color ranges to keep
filterHSL.Hue = new IntRange(Convert.ToInt32(HueLow), Convert.ToInt32(HueHigh));
filterHSL.Saturation = new Range((float)SatLow, (float)SatHigh);
filterHSL.Luminance = new Range((float)ValLow, (float)ValHigh);
// apply the filter
if (cbxTargetFrame.Checked)
{
filterHSL.ApplyInPlace(image);
}
else
{
filterHSL.ApplyInPlace(hsl);
}
//Process blobs
BlobCounter bc = new BlobCounter();
bc.ObjectsOrder = ObjectsOrder.Area;
if (cbxTargetFrame.Checked)
{
bc.ProcessImage(image);
}
else
{
bc.ProcessImage(hsl);
}
//show HSL values for selected pixel
if (colorRequested)
{
try
{
colorRequested = false;
int x = colorX * image.Width / vspTarget.ClientSize.Width;
int y = colorY * image.Height / vspTarget.ClientSize.Height;
Color c = image.GetPixel(x, y);
var xrgb = new RGB(c);
var xhsl = new HSL();
xhsl = HSL.FromRGB(xrgb);
hue = xhsl.Hue;
sat = xhsl.Saturation;
lum = xhsl.Luminance;
this.Text = "HUE: " + hue.ToString("N0") + " SAT: " + sat.ToString("N2") + " LUM: " + lum.ToString("N2");
}
catch { };
}
using (Graphics g = Graphics.FromImage(image))
{
Rectangle[] rects = bc.GetObjectsRectangles();
try
{
if (rects.Length > 0)
{
//collect info
targetWidth = filter(Convert.ToInt32(rects[0].Width), targetWidth, outputFilter);
targetHeight = filter(Convert.ToInt32(rects[0].Height), targetHeight, outputFilter);
double area = targetHeight * targetWidth;
targetArea = ffilter(area, targetArea, outputFilter);
if (targetWidth > 0 && targetHeight > 0)
{
targetAspectRatio = ffilter(Convert.ToDouble(targetWidth) / Convert.ToDouble(targetHeight), targetAspectRatio, outputFilter);
}
double tmpDist = (focal * calHeight) / targetHeight;
if (!double.IsInfinity(tmpDist))
{
targetDistance = ffilter(tmpDist, targetDistance, outputFilter);
}
targetX = ffilter(rects[0].X + (rects[0].Width / 2), targetX, outputFilter);
targetY = ffilter(rects[0].Y + (rects[0].Height / 2), targetY, outputFilter);
HorizontalDegreesPerPixel = HFOV / Convert.ToDouble(image.Width);
targetAngle = ffilter((targetX - (Convert.ToDouble(image.Width) / 2)) * HorizontalDegreesPerPixel, targetAngle, outputFilter);
if (image.Width > 0)
{
targetSteer = ffilter(Normalize(targetAngle, STEERMIN, STEERMAX, -1.0, 1.0), targetSteer, outputFilter);
}
targetVisible = true;
if (cbUseAreaFilter.Checked)
{
if (targetArea < AreaLow || targetArea > AreaHigh)
{
targetVisible = false;
}
}
if (cbUseAreaRatioFilter.Checked)
{
if (targetAspectRatio < AspectRatioLow || targetAspectRatio > AspectRatioHigh)
{
targetVisible = false;
}
}
if (cbUseWidthFilter.Checked)
{
if (targetWidth < WidthLow || targetWidth > WidthHigh)
{
targetVisible = false;
}
}
if (cbUseHeightFilter.Checked)
{
if (targetHeight < HeightLow || targetHeight > HeightHigh)
{
targetVisible = false;
}
}
if (nt.IsConnected)
{
nt.PutNumber("targetX", targetX);
nt.PutNumber("targetY", targetY);
nt.PutNumber("targetDistance", targetDistance);
nt.PutNumber("targetAngle", targetAngle);
nt.PutNumber("targetSteer", targetSteer);
nt.PutBoolean("targetVisible", targetVisible);
}
}
else
{
targetVisible = false;
if (nt.IsConnected)
{
nt.PutBoolean("targetVisible", targetVisible);
}
}
if (targetVisible)
{
//Draw Bounding Rectangle
if (rects.Length > 0)
{
g.DrawRectangle(new Pen(Color.Red, 1), rects[0]);
}
}
}
catch { };
}
}
}
}
protected unsafe override void ProcessFilter(UnmanagedImage image, Rectangle rect)
{
int num = (image.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4;
int left = rect.Left;
int top = rect.Top;
int num2 = left + rect.Width;
int num3 = top + rect.Height;
int num4 = image.Stride - rect.Width * num;
RGB rGB = new RGB();
HSL hSL = new HSL();
byte *ptr = (byte *)image.ImageData.ToPointer();
ptr += top * image.Stride + left * num;
for (int i = top; i < num3; i++)
{
int num5 = left;
while (num5 < num2)
{
bool flag = false;
rGB.Red = ptr[2];
rGB.Green = ptr[1];
rGB.Blue = *ptr;
HSL.FromRGB(rGB, hSL);
if (hSL.Saturation >= saturation.Min && hSL.Saturation <= saturation.Max && hSL.Luminance >= luminance.Min && hSL.Luminance <= luminance.Max && ((hue.Min < hue.Max && hSL.Hue >= hue.Min && hSL.Hue <= hue.Max) || (hue.Min > hue.Max && (hSL.Hue >= hue.Min || hSL.Hue <= hue.Max))))
{
if (!fillOutsideRange)
{
if (updateH)
{
hSL.Hue = fillH;
}
if (updateS)
{
hSL.Saturation = fillS;
}
if (updateL)
{
hSL.Luminance = fillL;
}
flag = true;
}
}
else if (fillOutsideRange)
{
if (updateH)
{
hSL.Hue = fillH;
}
if (updateS)
{
hSL.Saturation = fillS;
}
if (updateL)
{
hSL.Luminance = fillL;
}
flag = true;
}
if (flag)
{
HSL.ToRGB(hSL, rGB);
ptr[2] = rGB.Red;
ptr[1] = rGB.Green;
*ptr = rGB.Blue;
}
num5++;
ptr += num;
}
ptr += num4;
}
}
protected unsafe override void ProcessFilter(UnmanagedImage image, Rectangle rect)
{
int num = System.Drawing.Image.GetPixelFormatSize(image.PixelFormat) / 8;
int left = rect.Left;
int top = rect.Top;
int num2 = left + rect.Width;
int num3 = top + rect.Height;
int num4 = image.Stride - rect.Width * num;
RGB rGB = new RGB();
HSL hSL = new HSL();
float num5 = 0f;
float num6 = 0f;
float num7 = 0f;
float num8 = 0f;
if (inLuminance.Max != inLuminance.Min)
{
num5 = (outLuminance.Max - outLuminance.Min) / (inLuminance.Max - inLuminance.Min);
num6 = outLuminance.Min - num5 * inLuminance.Min;
}
if (inSaturation.Max != inSaturation.Min)
{
num7 = (outSaturation.Max - outSaturation.Min) / (inSaturation.Max - inSaturation.Min);
num8 = outSaturation.Min - num7 * inSaturation.Min;
}
byte *ptr = (byte *)image.ImageData.ToPointer();
ptr += top * image.Stride + left * num;
for (int i = top; i < num3; i++)
{
int num9 = left;
while (num9 < num2)
{
rGB.Red = ptr[2];
rGB.Green = ptr[1];
rGB.Blue = *ptr;
HSL.FromRGB(rGB, hSL);
if (hSL.Luminance >= inLuminance.Max)
{
hSL.Luminance = outLuminance.Max;
}
else if (hSL.Luminance <= inLuminance.Min)
{
hSL.Luminance = outLuminance.Min;
}
else
{
hSL.Luminance = num5 * hSL.Luminance + num6;
}
if (hSL.Saturation >= inSaturation.Max)
{
hSL.Saturation = outSaturation.Max;
}
else if (hSL.Saturation <= inSaturation.Min)
{
hSL.Saturation = outSaturation.Min;
}
else
{
hSL.Saturation = num7 * hSL.Saturation + num8;
}
HSL.ToRGB(hSL, rGB);
ptr[2] = rGB.Red;
ptr[1] = rGB.Green;
*ptr = rGB.Blue;
num9++;
ptr += num;
}
ptr += num4;
}
}
protected override unsafe void ProcessFilter(UnmanagedImage image, Rectangle rect)
{
int num = Image.GetPixelFormatSize(image.PixelFormat) / 8;
int left = rect.Left;
int top = rect.Top;
int num4 = left + rect.Width;
int num5 = top + rect.Height;
int num6 = image.Stride - (rect.Width * num);
RGB rgb = new RGB();
HSL hsl = new HSL();
double num7 = 0.0;
double num8 = 0.0;
double num9 = 0.0;
double num10 = 0.0;
if (this.inLuminance.Max != this.inLuminance.Min)
{
num7 = (this.outLuminance.Max - this.outLuminance.Min) / (this.inLuminance.Max - this.inLuminance.Min);
num8 = this.outLuminance.Min - (num7 * this.inLuminance.Min);
}
if (this.inSaturation.Max != this.inSaturation.Min)
{
num9 = (this.outSaturation.Max - this.outSaturation.Min) / (this.inSaturation.Max - this.inSaturation.Min);
num10 = this.outSaturation.Min - (num9 * this.inSaturation.Min);
}
byte *numPtr = (byte *)(image.ImageData.ToPointer() + ((top * image.Stride) + (left * num)));
for (int i = top; i < num5; i++)
{
int num12 = left;
while (num12 < num4)
{
rgb.Red = numPtr[2];
rgb.Green = numPtr[1];
rgb.Blue = numPtr[0];
HSL.FromRGB(rgb, hsl);
if (hsl.Luminance >= this.inLuminance.Max)
{
hsl.Luminance = this.outLuminance.Max;
}
else if (hsl.Luminance <= this.inLuminance.Min)
{
hsl.Luminance = this.outLuminance.Min;
}
else
{
hsl.Luminance = (num7 * hsl.Luminance) + num8;
}
if (hsl.Saturation >= this.inSaturation.Max)
{
hsl.Saturation = this.outSaturation.Max;
}
else if (hsl.Saturation <= this.inSaturation.Min)
{
hsl.Saturation = this.outSaturation.Min;
}
else
{
hsl.Saturation = (num9 * hsl.Saturation) + num10;
}
HSL.ToRGB(hsl, rgb);
numPtr[2] = rgb.Red;
numPtr[1] = rgb.Green;
numPtr[0] = rgb.Blue;
num12++;
numPtr += num;
}
numPtr += num6;
}
}
/// <summary>
/// Converts a Bitmap to an HSL structure with or without alpha-channel.
/// </summary>
/// <param name="bmData">Bitmap data</param>
/// <param name="alpha">Alpha-channel</param>
/// <returns>HSL structure array</returns>
public unsafe static float[][,] ToHSL(this BitmapData bmData, bool alpha = false)
{
// params
int width = bmData.Width, height = bmData.Height, stride = bmData.Stride;
byte *p = (byte *)bmData.Scan0.ToPointer();
// matrices
float[,] x = new float[height, width];
float[,] y = new float[height, width];
float[,] z = new float[height, width];
// with alpha channel
if (alpha)
{
float[,] a = new float[height, width];
Parallel.For(0, height, j =>
{
HSL mdl;
int i, k, jstride = j * stride;
for (i = 0; i < width; i++)
{
// shift:
k = jstride + i * 4;
mdl = HSL.FromRGB(p[k + 2], p[k + 1], p[k + 0]);
x[j, i] = mdl.Hue;
y[j, i] = mdl.Saturation;
z[j, i] = mdl.Lightness;
a[j, i] = p[k + 3] / 255.0f;
}
});
return(new float[][, ] {
x, y, z, a
});
}
// without alpha channel
Parallel.For(0, height, j =>
{
HSL mdl;
int i, k, jstride = j * stride;
for (i = 0; i < width; i++)
{
// shift:
k = jstride + i * 4;
mdl = HSL.FromRGB(p[k + 2], p[k + 1], p[k + 0]);
x[j, i] = mdl.Hue;
y[j, i] = mdl.Saturation;
z[j, i] = mdl.Lightness;
}
});
return(new float[][, ] {
x, y, z
});
}