public void ToBitmap_ReturnsBitmapOfMatrix()
{
var matrix = MatrixPopulator.CreateIncrementedDummy(4, 4);
var bitmap = matrix.ToBitmap(c => c.Value);
Assert.NotNull(bitmap);
}
public void RectBoxedAlgo_CorrectSize()
{
var matrix = MatrixPopulator.CreateIncrementedDummy(4, 4);
var sum = matrix.RectBoxedAlgo(3, 3, (_, _, m) => m.Sum(c => c.Value));
Assert.AreEqual(2, sum.Rows);
Assert.AreEqual(2, sum.Columns);
}
public void CalculateMatrixParameters_CalculatesRemainingCorrect1()
{
var matrix = MatrixPopulator.CreateIncrementedInt(100, 200);
MatrixFilter.CalculateMatrixParameters(matrix, 3, 11, 1, 1, out _, out _, out var remainingRows, out var remainingColumns);
Assert.AreEqual(98, remainingRows);
Assert.AreEqual(190, remainingColumns);
}
public void CalculateMatrixParameters_CalculatesOffsetCorrect1()
{
var matrix = MatrixPopulator.CreateIncrementedInt(100, 200);
MatrixFilter.CalculateMatrixParameters(matrix, 31, 21, 1, 1, out var rowOffset, out var colOffset, out _, out _);
Assert.AreEqual(15, rowOffset);
Assert.AreEqual(10, colOffset);
}
public void ToMatrix_ConvertBitmapToMatrix()
{
var initMatrix = MatrixPopulator.CreateIncrementedDummy(4, 4);
var bitmap = initMatrix.ToBitmap((_, _, v) => Color.FromArgb(v.Value, v.Value, v.Value));
var matrix = bitmap.ToMatrix((_, _, color) => new MatrixPopulator.Dummy(color.G));
Assert.AreEqual(initMatrix, matrix);
}
public void ToMatrix_UnevenMatrix_ConvertBitmapToMatrix()
{
var initMatrix = MatrixPopulator.CreateIncrementedDummy(4, 4);
var expected = initMatrix.AddPadding(2, 0, 2, 0, new MatrixPopulator.Dummy(10));
var bitmap = expected.ToBitmap((_, _, v) => Color.FromArgb(v.Value, v.Value, v.Value));
var matrix = bitmap.ToMatrix((_, _, color) => new MatrixPopulator.Dummy(color.G));
Assert.AreEqual(expected, matrix);
}
public void RectBoxedAlgo_ReturnSum()
{
var matrix = MatrixPopulator.CreateIncrementedDummy(4, 4);
var expected = new Matrix <double>(new double[, ]
{
{ 54, 63 },
{ 90, 99 }
});
var sum = matrix.RectBoxedAlgo(3, 3, (_, _, m) => m.Sum(c => c.Value));
Assert.AreEqual(expected, sum);
}
public void GetBox_ReturnsBox()
{
var mat = MatrixPopulator.CreateIncrementedInt(9, 9);
var box = mat.GetBox(2, 2, 3);
var expectedBox = new Matrix <int>(new[, ]
{
{ 11, 12, 13 },
{ 20, 21, 22 },
{ 29, 30, 31 }
});
Assert.AreEqual(expectedBox, box);
}
public void GetFromRegion()
{
var mat = MatrixPopulator.CreateIncrementedInt(9, 9);
var matReg = mat.GetRect(RegionHelper.FromCenter(3, 2, 3, 5));
var expectedBox = new Matrix <int>(new[, ]
{
{ 19, 20, 21, 22, 23 },
{ 28, 29, 30, 31, 32 },
{ 37, 38, 39, 40, 41 }
});
Assert.AreEqual(expectedBox, matReg);
}
public void GetRect_ReturnsRect()
{
var mat = MatrixPopulator.CreateIncrementedInt(9, 9);
var box = mat.GetRect(2, 2, 3, 5);
var expectedBox = new Matrix <int>(new[, ]
{
{ 10, 11, 12, 13, 14 },
{ 19, 20, 21, 22, 23 },
{ 28, 29, 30, 31, 32 }
});
Assert.AreEqual(expectedBox, box);
}
public void GetBox_ReturnsBox_TakesPointInput2()
{
var mat = MatrixPopulator.CreateIncrementedInt(9, 9);
var box = mat.GetBox(new Point(3, 2), 3);
var expectedBox = new Matrix <int>(new[, ]
{
{ 12, 13, 14 },
{ 21, 22, 23 },
{ 30, 31, 32 }
});
Assert.AreEqual(expectedBox, box);
}
public void GetRect_ReturnsRect_TakesRectInput2()
{
var mat = MatrixPopulator.CreateIncrementedInt(9, 9);
var box = mat.GetRect(new Rectangle(1, 1, 5, 3));
var expectedBox = new Matrix <int>(new[, ]
{
{ 11, 12, 13, 14, 15 },
{ 20, 21, 22, 23, 24 },
{ 29, 30, 31, 32, 33 }
});
Assert.AreEqual(expectedBox, box);
}
public void TestPopulateMatrix(string chosenLetter, string assertLetter, int horizontalIndexLeft, int horizontalIndexRight, int verticalIndex)
{
// arrange
var lookup = new LetterLookupSvc(chosenLetter);
var matrixObject = new DiamondMatrix(lookup.ChosenLetterAlphabetIndex);
var matrix = matrixObject.Matrix;
var matrixPopulator = new MatrixPopulator();
// act
matrixPopulator.PopulateMatrix(matrix, lookup);
// assert
Assert.Equal(assertLetter, matrix[verticalIndex, horizontalIndexLeft]);
Assert.Equal(assertLetter, matrix[verticalIndex, horizontalIndexRight]);
}
public void RectBoxedSum_CheckResult([Values(300, 100, 30)] int matRows, [Values(300, 100, 30)] int matColumns, [Values(11, 5)] int rows, [Values(11, 5)] int columns, [Values(1, 2, 5, 10)] int yStride, [Values(1, 2, 5, 10)] int xStride)
{
// some combinations are illegal, skip them now!
if ((300 - columns + 1) % xStride != 0 ||
(300 - rows + 1) % yStride != 0 ||
columns < xStride ||
rows < yStride)
{
Assert.Pass("skipped: invalid combination");
}
var matrix = MatrixPopulator.CreateRandomDummy(matRows, matColumns, 0);
var expected = matrix.RectBoxedAlgo(rows, columns, (_, _, mat) => mat.Sum(c => c.Value), yStride, xStride);
var result = matrix.RectBoxedSum(rows, columns, c => c.Value, yStride, xStride);
Assert.AreEqual(expected, result);
}
public void CalculateMatrixParameters_Invalid_RowsColumns_ThrowsError(int rows, int columns)
{
var matrix = MatrixPopulator.CreateIncrementedInt(4, 4);
Assert.Throws <OutOfRangeException>(() => MatrixFilter.CalculateMatrixParameters(matrix, rows, columns, 1, 1, out _, out _, out _, out _));
}
public void GetBox_TakesPoint_OutOfRange_ThrowsException(int size)
{
var mat = MatrixPopulator.CreateIncrementedInt(9, 9);
Assert.Throws <IndexOutOfRangeException>(() => mat.GetBox(new Point(8, 8), size));
}
public void Min_ReturnsMinValueOfMatrix()
{
var matrix = MatrixPopulator.CreateIncrementedDummy(4, 4);
Assert.AreEqual(1, matrix.Min(c => c.Value));
}
public void Sum_CalculatesTotalSumOnMatrix()
{
var matrix = MatrixPopulator.CreateIncrementedDummy(4, 4);
Assert.AreEqual((16 * 16 + 16) / 2, matrix.Sum(c => c.Value));
}
public void CalculateMatrixParameters_StrideNotDivisibleByRemainingColumnsRows_ThrowsError(int yStride, int xStride)
{
var matrix = MatrixPopulator.CreateIncrementedInt(300, 600);
Assert.Throws <StrideException>(() => MatrixFilter.CalculateMatrixParameters(matrix, 11, 11, yStride, xStride, out _, out _, out _, out _));
}
public void CalculateMatrixParameters_StrideBiggerThanRowsColumns_ThrowsError(int yStride, int xStride)
{
var matrix = MatrixPopulator.CreateIncrementedInt(4, 6, 0);
Assert.Throws <StrideException>(() => MatrixFilter.CalculateMatrixParameters(matrix, 3, 3, yStride, xStride, out _, out _, out _, out _));
}
public void GetRect_OutOfRange_ThrowsException(int height, int width)
{
var mat = MatrixPopulator.CreateIncrementedInt(9, 9);
Assert.Throws <IndexOutOfRangeException>(() => mat.GetRect(1, 1, height, width));
}
public void CalculateMatrixParameters_EvenColumns_ThrowsError(int rows, int columns)
{
var matrix = MatrixPopulator.CreateRandomInt(10, 10);
Assert.Throws <EvenException>(() => MatrixFilter.CalculateMatrixParameters(matrix, rows, columns, 1, 1, out _, out _, out _, out _));
}
public void CalculateMatrixParameters_InvalidStride_ThrowsError(int yStride, int xStride)
{
var matrix = MatrixPopulator.CreateIncrementedInt(4, 6, 0);
Assert.Throws <OutOfRangeException>(() => MatrixFilter.CalculateMatrixParameters(matrix, 3, 3, yStride, xStride, out _, out _, out _, out _));
}
public void Average_CalculatesAverageOnMatrix()
{
var matrix = MatrixPopulator.CreateIncrementedDummy(4, 4);
Assert.AreEqual(8.5, matrix.Average(c => c.Value));
}
