public RgbAlphaPixel Operator(string str)
{
if (this._Colors.TryGetValue(str, out var value))
{
return(value);
}
var pix = new HsiPixel
{
H = Reverse((byte)this._Colors.Count),
S = byte.MaxValue,
I = 150
};
var result = new RgbAlphaPixel();
Dlib.AssignPixel(ref result, pix);
this._Colors[str] = result;
return(result);
}
public void GetRowColumn()
{
const int width = 150;
const int height = 100;
var tests = new[]
{
new { Type = ImageTypes.RgbPixel, ExpectResult = true },
new { Type = ImageTypes.RgbAlphaPixel, ExpectResult = true },
new { Type = ImageTypes.UInt8, ExpectResult = true },
new { Type = ImageTypes.UInt16, ExpectResult = true },
new { Type = ImageTypes.UInt32, ExpectResult = true },
new { Type = ImageTypes.Int8, ExpectResult = true },
new { Type = ImageTypes.Int16, ExpectResult = true },
new { Type = ImageTypes.Int32, ExpectResult = true },
new { Type = ImageTypes.HsiPixel, ExpectResult = true },
new { Type = ImageTypes.Float, ExpectResult = true },
new { Type = ImageTypes.Double, ExpectResult = true }
};
foreach (var test in tests)
{
var array2D = CreateArray2D(test.Type, height, width);
switch (array2D.ImageType)
{
case ImageTypes.UInt8:
{
var array = (Array2D <byte>)array2D;
Dlib.AssignAllPpixels(array, 255);
using (var row = array[0])
Assert.AreEqual(row[0], 255, "Array<byte> failed");
}
break;
case ImageTypes.UInt16:
{
var array = (Array2D <ushort>)array2D;
Dlib.AssignAllPpixels(array, 255);
using (var row = array[0])
Assert.AreEqual(row[0], 255, "Array<ushort> failed");
}
break;
case ImageTypes.UInt32:
{
var array = (Array2D <uint>)array2D;
Dlib.AssignAllPpixels(array, 255);
using (var row = array[0])
Assert.AreEqual(row[0], 255u, "Array<uint> failed");
}
break;
case ImageTypes.Int8:
{
var array = (Array2D <sbyte>)array2D;
Dlib.AssignAllPpixels(array, 127);
using (var row = array[0])
Assert.AreEqual(row[0], 127, "Array<sbyte> failed");
}
break;
case ImageTypes.Int16:
{
var array = (Array2D <short>)array2D;
Dlib.AssignAllPpixels(array, 255);
using (var row = array[0])
Assert.AreEqual(row[0], 255, "Array<short> failed");
}
break;
case ImageTypes.Int32:
{
var array = (Array2D <int>)array2D;
Dlib.AssignAllPpixels(array, 255);
using (var row = array[0])
Assert.AreEqual(row[0], 255, "Array<int> failed");
}
break;
case ImageTypes.Float:
{
var array = (Array2D <float>)array2D;
Dlib.AssignAllPpixels(array, 255);
using (var row = array[0])
Assert.AreEqual(row[0], 255, "Array<float> failed");
}
break;
case ImageTypes.Double:
{
var array = (Array2D <double>)array2D;
Dlib.AssignAllPpixels(array, 255);
using (var row = array[0])
Assert.AreEqual(row[0], 255, "Array<double> failed");
}
break;
case ImageTypes.RgbPixel:
{
var array = (Array2D <RgbPixel>)array2D;
var pixel = new RgbPixel
{
Red = 255,
Blue = 255,
Green = 255
};
Dlib.AssignAllPpixels(array, pixel);
using (var row = array[0])
{
var t = row[0];
Assert.AreEqual(t.Red, 255, "Array<RgbPixel> failed");
Assert.AreEqual(t.Blue, 255, "Array<RgbPixel> failed");
Assert.AreEqual(t.Green, 255, "Array<RgbPixel> failed");
}
}
break;
case ImageTypes.RgbAlphaPixel:
{
var array = (Array2D <RgbAlphaPixel>)array2D;
var pixel = new RgbAlphaPixel
{
Red = 255,
Blue = 255,
Green = 255,
Alpha = 255
};
Dlib.AssignAllPpixels(array, pixel);
using (var row = array[0])
{
var t = row[0];
Assert.AreEqual(t.Red, 255, "Array<RgbAlphaPixel> failed");
Assert.AreEqual(t.Blue, 255, "Array<RgbAlphaPixel> failed");
Assert.AreEqual(t.Green, 255, "Array<RgbAlphaPixel> failed");
Assert.AreEqual(t.Alpha, 255, "Array<RgbAlphaPixel> failed");
}
}
break;
case ImageTypes.HsiPixel:
{
var array = (Array2D <HsiPixel>)array2D;
var pixel = new HsiPixel
{
H = 255,
S = 255,
I = 255
};
Dlib.AssignAllPpixels(array, pixel);
using (var row = array[0])
{
var t = row[0];
Assert.AreEqual(t.H, 255, "Array<HsiPixel> failed");
Assert.AreEqual(t.S, 255, "Array<HsiPixel> failed");
Assert.AreEqual(t.I, 255, "Array<HsiPixel> failed");
}
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(array2D.ImageType), array2D.ImageType, null);
}
this.DisposeAndCheckDisposedState(array2D);
}
}
public void LoadImageData2()
{
const int cols = 512;
const int rows = 512;
const int steps = 512;
var tests = new[]
{
new { Type = ImageTypes.UInt8, ExpectResult = true },
new { Type = ImageTypes.UInt16, ExpectResult = true },
new { Type = ImageTypes.Int16, ExpectResult = true },
new { Type = ImageTypes.Int32, ExpectResult = true },
new { Type = ImageTypes.HsiPixel, ExpectResult = true },
new { Type = ImageTypes.RgbPixel, ExpectResult = true },
new { Type = ImageTypes.RgbAlphaPixel, ExpectResult = true },
new { Type = ImageTypes.Float, ExpectResult = true },
new { Type = ImageTypes.Double, ExpectResult = true }
};
var random = new Random(0);
foreach (var test in tests)
{
TwoDimentionObjectBase image;
using (var win = new ImageWindow())
{
switch (test.Type)
{
case ImageTypes.UInt8:
{
var data = new byte[rows * cols];
for (var r = 0; r < rows; r++)
{
for (var c = 0; c < cols; c++)
{
data[steps * r + c] = (byte)random.Next(0, 255);
}
}
image = Dlib.LoadImageData <byte>(data, rows, cols, steps);
if (this.CanGuiDebug)
{
win.SetImage((Array2D <byte>)image);
win.WaitUntilClosed();
}
}
break;
case ImageTypes.UInt16:
{
var data = new ushort[rows * cols];
for (var r = 0; r < rows; r++)
{
for (var c = 0; c < cols; c++)
{
data[steps * r + c] = (ushort)random.Next(0, 255);
}
}
image = Dlib.LoadImageData <ushort>(data, rows, cols, steps);
if (this.CanGuiDebug)
{
win.SetImage((Array2D <ushort>)image);
win.WaitUntilClosed();
}
}
break;
case ImageTypes.Int16:
{
var data = new short[rows * cols];
for (var r = 0; r < rows; r++)
{
for (var c = 0; c < cols; c++)
{
data[steps * r + c] = (short)random.Next(0, 255);
}
}
image = Dlib.LoadImageData <short>(data, rows, cols, steps);
if (this.CanGuiDebug)
{
win.SetImage((Array2D <short>)image);
win.WaitUntilClosed();
}
}
break;
case ImageTypes.Int32:
{
var data = new int[rows * cols];
for (var r = 0; r < rows; r++)
{
for (var c = 0; c < cols; c++)
{
data[steps * r + c] = random.Next(0, 255);
}
}
image = Dlib.LoadImageData <int>(data, rows, cols, steps);
if (this.CanGuiDebug)
{
win.SetImage((Array2D <int>)image);
win.WaitUntilClosed();
}
}
break;
case ImageTypes.Float:
{
var data = new float[rows * cols];
for (var r = 0; r < rows; r++)
{
for (var c = 0; c < cols; c++)
{
data[steps * r + c] = (float)random.NextDouble();
}
}
image = Dlib.LoadImageData <float>(data, rows, cols, steps);
if (this.CanGuiDebug)
{
win.SetImage((Array2D <float>)image);
win.WaitUntilClosed();
}
}
break;
case ImageTypes.Double:
{
var data = new double[rows * cols];
for (var r = 0; r < rows; r++)
{
for (var c = 0; c < cols; c++)
{
data[steps * r + c] = (double)random.NextDouble();
}
}
image = Dlib.LoadImageData <double>(data, rows, cols, steps);
if (this.CanGuiDebug)
{
win.SetImage((Array2D <double>)image);
win.WaitUntilClosed();
}
}
break;
case ImageTypes.HsiPixel:
{
var data = new HsiPixel[rows * cols];
for (var r = 0; r < rows; r++)
{
for (var c = 0; c < cols; c++)
{
data[steps * r + c] = new HsiPixel
{
H = (byte)random.Next(0, 255),
S = (byte)random.Next(0, 255),
I = (byte)random.Next(0, 255)
}
}
}
;
image = Dlib.LoadImageData <HsiPixel>(data, rows, cols, steps);
if (this.CanGuiDebug)
{
win.SetImage((Array2D <HsiPixel>)image);
win.WaitUntilClosed();
}
}
break;
case ImageTypes.RgbPixel:
{
var data = new RgbPixel[rows * cols];
for (var r = 0; r < rows; r++)
{
for (var c = 0; c < cols; c++)
{
data[steps * r + c] = new RgbPixel
{
Red = (byte)random.Next(0, 255),
Green = (byte)random.Next(0, 255),
Blue = (byte)random.Next(0, 255)
}
}
}
;
image = Dlib.LoadImageData <RgbPixel>(data, rows, cols, steps);
if (this.CanGuiDebug)
{
win.SetImage((Array2D <RgbPixel>)image);
win.WaitUntilClosed();
}
}
break;
case ImageTypes.RgbAlphaPixel:
{
var data = new RgbAlphaPixel[rows * cols];
for (var r = 0; r < rows; r++)
{
for (var c = 0; c < cols; c++)
{
data[steps * r + c] = new RgbAlphaPixel
{
Red = (byte)random.Next(0, 255),
Green = (byte)random.Next(0, 255),
Blue = (byte)random.Next(0, 255),
Alpha = (byte)random.Next(0, 255)
}
}
}
;
image = Dlib.LoadImageData <RgbAlphaPixel>(data, rows, cols, steps);
if (this.CanGuiDebug)
{
win.SetImage((Array2D <RgbAlphaPixel>)image);
win.WaitUntilClosed();
}
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
Assert.AreEqual(image.Columns, cols, $"Failed to load {test.Type}.");
Assert.AreEqual(image.Rows, rows, $"Failed to load {test.Type}.");
this.DisposeAndCheckDisposedState(image);
}
}
public void Indexer3()
{
try
{
using (var matrix = new Matrix <byte>(1, 3))
{
for (var index = 0; index < 3; index++)
{
var v = (byte)(index);
matrix[index] = v;
Assert.AreEqual(v, matrix[index]);
}
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(byte)}");
}
try
{
using (var matrix = new Matrix <ushort>(1, 3))
{
for (var index = 0; index < 3; index++)
{
var v = (ushort)(index);
matrix[index] = v;
Assert.AreEqual(v, matrix[index]);
}
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(ushort)}");
}
try
{
using (var matrix = new Matrix <uint>(1, 3))
{
for (var index = 0; index < 3; index++)
{
var v = (uint)(index);
matrix[index] = v;
Assert.AreEqual(v, matrix[index]);
}
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(uint)}");
}
try
{
using (var matrix = new Matrix <sbyte>(1, 3))
{
for (var index = 0; index < 3; index++)
{
var v = (sbyte)(index);
matrix[index] = v;
Assert.AreEqual(v, matrix[index]);
}
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(sbyte)}");
}
try
{
using (var matrix = new Matrix <short>(1, 3))
{
for (var index = 0; index < 3; index++)
{
var v = (short)(index);
matrix[index] = v;
Assert.AreEqual(v, matrix[index]);
}
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(short)}");
}
try
{
using (var matrix = new Matrix <int>(1, 3))
{
for (var index = 0; index < 3; index++)
{
var v = (int)(index);
matrix[index] = v;
Assert.AreEqual(v, matrix[index]);
}
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(int)}");
}
try
{
using (var matrix = new Matrix <float>(1, 3))
{
for (var index = 0; index < 3; index++)
{
var v = (float)(index);
matrix[index] = v;
Assert.AreEqual(v, matrix[index]);
}
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(float)}");
}
try
{
using (var matrix = new Matrix <double>(1, 3))
{
for (var index = 0; index < 3; index++)
{
var v = (double)(index);
matrix[index] = v;
Assert.AreEqual(v, matrix[index]);
}
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(double)}");
}
try
{
using (var matrix = new Matrix <RgbPixel>(1, 3))
for (var index = 0; index < 3; index++)
{
var b = (byte)(index);
var v = new RgbPixel {
Red = b, Blue = b, Green = b
};
matrix[index] = v;
Assert.AreEqual(v.Red, matrix[index].Red);
Assert.AreEqual(v.Blue, matrix[index].Blue);
Assert.AreEqual(v.Green, matrix[index].Green);
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(RgbPixel)}");
}
try
{
using (var matrix = new Matrix <RgbAlphaPixel>(1, 3))
for (var index = 0; index < 3; index++)
{
var b = (byte)(index);
var v = new RgbAlphaPixel {
Red = b, Blue = b, Green = b
};
matrix[index] = v;
Assert.AreEqual(v.Red, matrix[index].Red);
Assert.AreEqual(v.Blue, matrix[index].Blue);
Assert.AreEqual(v.Green, matrix[index].Green);
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(RgbPixel)}");
}
try
{
using (var matrix = new Matrix <HsiPixel>(1, 3))
for (var index = 0; index < 3; index++)
{
var b = (byte)(index);
var v = new HsiPixel {
H = b, S = b, I = b
};
matrix[index] = v;
Assert.AreEqual(v.H, matrix[index].H);
Assert.AreEqual(v.S, matrix[index].S);
Assert.AreEqual(v.I, matrix[index].I);
}
}
catch (Exception)
{
Assert.Fail($"Failed to access for Type: {typeof(HsiPixel)}");
}
}
