public void PixelMatrix_skips()
{
try
{
List <int> dimensions = ReturnPixelJumps();
Stopwatch sw = new Stopwatch();
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"f:\temp\runtime\pixelmatrixanalysis_jumps.txt", true))
{
for (int i = 0; i < dimensions.Count; i++)
{
for (int n = 0; n < 200; n++)
{
BitmapWrapper bm1 = new BitmapWrapper(@"F:\temp\analysis\640x480\test_0.jpg");
BitmapWrapper bm2 = new BitmapWrapper(@"F:\temp\analysis\640x480\test_1.jpg");
sw.Restart();
PixelMatrix matrix = new PixelMatrix();
matrix.WidthSearchOffset = dimensions[i];
matrix.Populate(bm1, bm2);
sw.Stop();
file.WriteLine(i + " - " + n + " - " + " grid - " + sw.Elapsed.TotalMilliseconds);
}
}
}
Assert.IsTrue(true);
}
catch
{
Assert.IsTrue(false);
}
}
public void Motion2aMultipleCompare()
{
try
{
//images in memory when sent to the
ByteWrapper image1 = ImageConvert.ReturnByteWrapper(@"F:\temp\analysis\640x480\test_0.jpg");
ByteWrapper image2 = ImageConvert.ReturnByteWrapper(@"F:\temp\analysis\640x480\test_1.jpg");
PixelMatrix dummy = new PixelMatrix();
dummy.LinkCompare = true;
dummy.Populate(new BitmapWrapper(ImageConvert.ReturnBitmap(image1.bytes)), new BitmapWrapper(ImageConvert.ReturnBitmap(image2.bytes)));
MotionSensor_2a motion = new MotionSensor_2a();
motion.ThresholdSet = true;
motion.settings.linkCompare = true;
motion.Comparison = dummy.Comparision;
motion.ImageCreated(image1, EventArgs.Empty);
motion.ImageCreated(image2, EventArgs.Empty);
motion.ImageCreated(image1, EventArgs.Empty);
motion.ImageCreated(image2, EventArgs.Empty);
Assert.IsTrue(true);
}
catch
{
Assert.IsTrue(false);
}
}
//Draws a circle on the bitmap using Bresenham
public static PixelMatrix BresenhamCircle(PixelMatrix bitmap, int centerX, int centerY, int radius, Color color)
{
int d = (5 - radius * 4) / 4;
int x = 0;
int y = radius;
do
{
bitmap.SetPixel(centerX + x, centerY + y, color);
bitmap.SetPixel(centerX + x, centerY - y, color);
bitmap.SetPixel(centerX - x, centerY + y, color);
bitmap.SetPixel(centerX - x, centerY - y, color);
bitmap.SetPixel(centerX + y, centerY + x, color);
bitmap.SetPixel(centerX + y, centerY - x, color);
bitmap.SetPixel(centerX - y, centerY + x, color);
bitmap.SetPixel(centerX - y, centerY - x, color);
if (d < 0)
{
d += 2 * x + 1;
}
else
{
d += 2 * (x - y) + 1;
y--;
}
x++;
} while (x <= y);
return(bitmap);
}
//Rotate an image by increments of 90 degrees
public static PixelMatrix RotateSq(PixelMatrix original, int rotates)
{
//No more rotates
if (rotates == 0)
{
return(original);
}
//Setup new rotated
int side = Mathf.Max(original.width, original.height);
PixelMatrix rotated = new PixelMatrix(side, side, Color.clear);
//Rotate 90º
for (int i = 0; i < original.width; i++)
{
int finalI = original.width - i - 1;
for (int j = 0; j < original.height; j++)
{
rotated.SetPixelSafe(j, finalI, original.GetPixelSafe(i, j));
}
}
//Call new rotation
rotated = RotateSq(rotated, rotates - 1);
return(rotated);
}
//Draws a line on the bitmap using Bresenham
public static PixelMatrix BresenhamLine(PixelMatrix bitmap, int x0, int y0, int x1, int y1, Color color)
{
int dx = Mathf.Abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
int dy = Mathf.Abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
int err = (dx > dy ? dx : -dy) / 2, e2;
do
{
bitmap.SetPixel(x0, y0, color);
if (x0 == x1 && y0 == y1)
{
break;
}
e2 = err;
if (e2 > -dx)
{
err -= dy;
x0 += sx;
}
if (e2 < dy)
{
err += dx;
y0 += sy;
}
} while (true);
return(bitmap);
}
//Draws a line on the bitmap using Bresenham and thickness
public static PixelMatrix BresenhamLineThick(PixelMatrix bitmap, int x0, int y0, int x1, int y1, Color color, int thickness)
{
//Prepare filled circle
PixelMatrix decal = FilledCircle(thickness, color);
int dx = Mathf.Abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
int dy = Mathf.Abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
int err = (dx > dy ? dx : -dy) / 2, e2;
do
{
bitmap = Decal(bitmap, decal, x0, y0);
if (x0 == x1 && y0 == y1)
{
break;
}
e2 = err;
if (e2 > -dx)
{
err -= dy; x0 += sx;
}
if (e2 < dy)
{
err += dx; y0 += sy;
}
} while (true);
return(bitmap);
}
/// <summary>
/// Calculates the best-fitting character based on Mean squared error. See <see cref="RenderOption.CalculateCharForMatrix(PixelMatrix)"/> and <see cref="https://en.wikipedia.org/wiki/Mean_squared_error"/> for more information.
/// </summary>
/// <param name="tile">The part of the image to be represented.</param>
/// <returns>The best-fitting character and its corresponding PixelMatrix.</returns>
public override KeyValuePair <char, PixelMatrix> CalculateCharForMatrix(PixelMatrix tile)
{
double minScore = double.MaxValue;
KeyValuePair <char, PixelMatrix> bestFit = Font.Chars.FirstOrDefault();
foreach (var item in Font.Chars)
{
double score = 0;
for (int y = 0; y < Font.CharSize.Height; y++)
{
for (int x = 0; x < Font.CharSize.Width; x += Utils.BytesPerPixel)
{
byte grayChar = Utils.ColorToGray(item.Value.GetPixel(x, y));
byte grayMatrix = Utils.ColorToGray(tile.GetPixel(x, y));
score += (grayMatrix - grayChar) * (grayMatrix - grayChar);
}
}
if (score < minScore)
{
bestFit = item;
minScore = score;
}
}
return(bestFit);
}
//Scan-line flood fill, much faster
//https://lodev.org/cgtutor/floodfill.html#Scanline_Floodfill_Algorithm_With_Stack
public static PixelMatrix FloodFillLine(PixelMatrix bmp, int x, int y, Color replacementColor)
{
Point pt = new Point(x, y);
Color targetColor = bmp.GetPixel(pt.x, pt.y);
if (targetColor == replacementColor)
{
return(bmp);
}
Stack <Point> pixels = new Stack <Point>();
pixels.Push(pt);
while (pixels.Count != 0)
{
Point temp = pixels.Pop();
int y1 = temp.y;
while (y1 >= 0 && bmp.GetPixel(temp.x, y1) == targetColor)
{
y1--;
}
y1++;
bool spanLeft = false;
bool spanRight = false;
while (y1 < bmp.height && bmp.GetPixel(temp.x, y1) == targetColor)
{
bmp.SetPixelSafe(temp.x, y1, replacementColor);
Color clm1 = bmp.GetPixel(temp.x - 1, y1);
Color clp1 = bmp.GetPixel(temp.x + 1, y1);
if (!spanLeft && temp.x > 0 && clm1 == targetColor)
{
pixels.Push(new Point(temp.x - 1, y1));
spanLeft = true;
}
else if (spanLeft && temp.x - 1 >= 0 && clm1 != targetColor)
{
spanLeft = false;
}
if (!spanRight && temp.x < bmp.width - 1 && clp1 == targetColor)
{
pixels.Push(new Point(temp.x + 1, y1));
spanRight = true;
}
else if (spanRight && temp.x < bmp.width - 1 && clp1 != targetColor)
{
spanRight = false;
}
y1++;
}
}
return(bmp);
}
} //the thresholds, per grid
public override void Compare(ByteWrapper image1, ByteWrapper image2)
{
var bm1 = new BitmapWrapper(ImageConvert.ReturnBitmap(image1.bytes));
var bm2 = new BitmapWrapper(ImageConvert.ReturnBitmap(image2.bytes));
PixelMatrix matrix = new PixelMatrix();
if (settings.searchHeight > 0)
{
matrix.SearchHeight = settings.searchHeight;
}
if (settings.searchWidth > 0)
{
matrix.SearchWidth = settings.searchWidth;
}
if (settings.linkCompare)
{
matrix.LinkCompare = true;
}
matrix.GridSystemOn = true;
matrix.Populate(bm1, bm2);
double sumChangedPixels = matrix.SumChangedPixels;
//keep adding for threshold calculation, set the threshold, or monitor
if (ThresholdSet)
{
//do the motion detection
for (int i = 0; i < ThresholdImage.Columns.Count; i++)
{
for (int n = 0; n < ThresholdImage.Columns[i].grids.Count; n++)
{
if (matrix.imageGrid.Columns[i].grids[n].change > ThresholdImage.Columns[i].grids[n].threshold)
{
OnMotion(image1, image2, ThresholdImage.GridNumber(i, n));
return;
}
}
}
}
else if (!ThresholdSet && gridImages.Count < ControlImageNumber)
{
gridImages.Add(matrix.imageGrid); //keep adding for the later threshold calculation
}
else
{
SetThreshold(); //enough images received to set the threshold and start monitoring
}
Comparison = matrix.Comparator;
//clean up the memory
matrix.Dispose();
bm1.bitmap.Dispose();
bm2.bitmap.Dispose();
bm1 = null;
bm2 = null;
}//Compare
//Draw a filled box
public static PixelMatrix FilledBox(int width, int height, Color color)
{
//New Decal
PixelMatrix decal = new PixelMatrix(width, height, new Color(0, 0, 0, 0));
//Box perimeter
decal = Border(decal, color);
//Fill box
decal = FloodFillLine(decal, width / 2, height / 2, color);
return(decal);
}
public void Grid()
{
PixelMatrix matrix = new PixelMatrix();
matrix.GridSystemOn = true;
matrix.Populate(@"d:\temp\MotionSensor\2.2\test_101.jpg", @"d:\temp\MotionSensor\2.2\test_128.jpg");
Assert.IsNotNull(matrix.imageGrid.Columns);
Assert.IsTrue(matrix.imageGrid.Columns.Count == 4);
Assert.IsTrue(matrix.imageGrid.Columns[0].grids.Count == 4);
Assert.IsTrue(matrix.imageGrid.Columns[1].grids.Count == 4);
Assert.IsTrue(matrix.imageGrid.Columns[2].grids.Count == 4);
Assert.IsTrue(matrix.imageGrid.Columns[3].grids.Count == 4);
}
//Draws a border on the bitmap
public static PixelMatrix Border(PixelMatrix bitmap, Color color)
{
for (int i = 0; i < bitmap.height; i++)
{
bitmap.SetPixelSafe(0, i, color);
bitmap.SetPixelSafe(bitmap.width - 1, i, color);
}
for (int i = 0; i < bitmap.width; i++)
{
bitmap.SetPixelSafe(i, 0, color);
bitmap.SetPixelSafe(i, bitmap.height - 1, color);
}
return(bitmap);
}
//Draw a filled circle
public static PixelMatrix FilledCircle(int radius, Color color)
{
//New Decal
int size = radius * 2 + 1;
PixelMatrix decal = new PixelMatrix(size, size, new Color(0, 0, 0, 0));
//Circle perimeter
decal = BresenhamCircle(decal, radius, radius, radius, color);
//Fill circle
decal = FloodFillLine(decal, radius, radius, color);
return(decal);
}
public void Motion2aSubequent()
{
try
{
List <int> dimensions = ReturnDimensions();
Stopwatch sw = new Stopwatch();
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"f:\temp\runtime\motion_analysis.txt", true))
{
for (int i = 0; i < dimensions.Count; i++)
{
for (int n = 0; n < 200; n++)
{
//images in memory when sent to the
ByteWrapper image1 = ImageConvert.ReturnByteWrapper(@"F:\temp\analysis\640x480\test_0.jpg");
image1.sequenceNumber = i;
ByteWrapper image2 = ImageConvert.ReturnByteWrapper(@"F:\temp\analysis\640x480\test_1.jpg");
image2.sequenceNumber = i;
PixelMatrix dummy = new PixelMatrix();
dummy.LinkCompare = true;
dummy.SearchWidth = dimensions[i];
dummy.Populate(new BitmapWrapper(ImageConvert.ReturnBitmap(image1.bytes)), new BitmapWrapper(ImageConvert.ReturnBitmap(image2.bytes)));
sw.Restart();
MotionSensor_2a motion = new MotionSensor_2a();
motion.ThresholdSet = true;
motion.settings.linkCompare = true;
motion.settings.searchWidth = dimensions[i];
motion.Comparison = dummy.Comparision;
motion.ImageCreated(image1, EventArgs.Empty);
motion.ImageCreated(image2, EventArgs.Empty);
motion.ImageCreated(image1, EventArgs.Empty);
motion.ImageCreated(image2, EventArgs.Empty);
sw.Stop();
file.WriteLine(i + " - " + n + " - " + " no grid - " + sw.Elapsed.TotalMilliseconds);
}
}
}
Assert.IsTrue(true);
}
catch
{
Assert.IsTrue(false);
}
}
public void GridPopulation()
{
PixelMatrix matrix = new PixelMatrix();
matrix.GridSystemOn = true;
matrix.Populate(@"d:\temp\MotionSensor\2.2\test_101.jpg", @"d:\temp\MotionSensor\2.2\test_128.jpg");
for (int i = 0; i < matrix.imageGrid.Columns.Count; i++)
{
for (int n = 0; n < matrix.imageGrid.Columns[i].grids.Count; n++)
{
Assert.IsTrue(matrix.imageGrid.Columns[i].grids[n].change != 0);
}
}
}//GridPopulation
/// <summary>
/// Calculates the best-fitting character based on the brightness. See <see cref="RenderOption.CalculateCharForMatrix(PixelMatrix)"/> for more information.
/// </summary>
/// <param name="tile">The part of the image to be represented.</param>
/// <returns>The best-fitting character and its corresponding PixelMatrix.</returns>
public override KeyValuePair <char, PixelMatrix> CalculateCharForMatrix(PixelMatrix tile)
{
KeyValuePair <char, PixelMatrix> bestFit = Font.Chars.FirstOrDefault();
foreach (var item in Font.Chars)
{
if (RenderingMode == RenderingMode.Default && item.Value.CompareBrightness(tile) < bestFit.Value.CompareBrightness(tile))
{
bestFit = item;
}
else if (RenderingMode == RenderingMode.Inverted && item.Value.CompareBrightness(tile) > bestFit.Value.CompareBrightness(tile))
{
bestFit = item;
}
}
return(bestFit);
}
internal T Convert(BitmapSource source, IProgress <double> progress)
{
if (source.Format != Utils.PixelFormat)
{
source = new FormatConvertedBitmap(source, Utils.PixelFormat, null, 0);
}
List <PixelMatrix> tiles = PixelMatrix.CreateTiles(source, new Size(RenderOptions.TileSize.Width, RenderOptions.TileSize.Height));
int width = source.PixelWidth - (source.PixelWidth % RenderOptions.TileSize.Width);
int height = source.PixelHeight - (source.PixelHeight % RenderOptions.TileSize.Height);
InitializeOutput(new Size(width, height));
int tempCount = 0;
if (_parallelConversion)
{
Parallel.For(0, tiles.Count, i =>
{
AddToOutput(RenderOptions.CalculateCharForMatrix(tiles[i]), new Point(i % (width / RenderOptions.TileSize.Width) * RenderOptions.TileSize.Width, i / (width / RenderOptions.TileSize.Width) * RenderOptions.TileSize.Height), tiles[i]);
if (progress != null)
{
progress.Report((double)tempCount / tiles.Count);
tempCount++;
}
});
}
else
{
for (int i = 0; i < tiles.Count; i++)
{
AddToOutput(RenderOptions.CalculateCharForMatrix(tiles[i]), new Point(i % (width / RenderOptions.TileSize.Width) * RenderOptions.TileSize.Width, i / (width / RenderOptions.TileSize.Width) * RenderOptions.TileSize.Height), tiles[i]);
if (progress != null)
{
progress.Report((double)tempCount / tiles.Count);
tempCount++;
}
}
}
return(FinalizeOutput());
}
/// <summary>
/// Calculates the best-fitting character based on Structural similarity index. See <see cref="RenderOption.CalculateCharForMatrix(PixelMatrix)"/> and <see cref="https://en.wikipedia.org/wiki/Structural_similarity"/> for more information.
/// </summary>
/// <param name="tile">The part of the image to be represented.</param>
/// <returns>The best-fitting character and its corresponding PixelMatrix.</returns>
public override KeyValuePair <char, PixelMatrix> CalculateCharForMatrix(PixelMatrix tile)
{
double maxScore = RenderingMode == RenderingMode.Default ? double.MinValue : double.MaxValue;
KeyValuePair <char, PixelMatrix> bestFit = Font.Chars.FirstOrDefault();
foreach (var item in Font.Chars)
{
double score = 0;
double covariance = 0;
for (int y = 0; y < Font.CharSize.Height; y++)
{
for (int x = 0; x < Font.CharSize.Width; x += Utils.BytesPerPixel)
{
byte grayChar = Utils.ColorToGray(item.Value.GetPixel(x, y));
byte grayMatrix = Utils.ColorToGray(tile.GetPixel(x, y));
covariance += (grayChar - item.Value.Mean) * (grayMatrix - tile.Mean);
}
}
covariance /= Font.CharSize.Height * Font.CharSize.Width;
score = (2 * Math.Sqrt(item.Value.Variance) * Math.Sqrt(tile.Variance) + C1) * (2 * covariance + C2);
score /= (item.Value.Mean * item.Value.Mean + tile.Mean * tile.Mean + C1) * (covariance * covariance + C2);
if (RenderingMode == RenderingMode.Default && score > maxScore)
{
bestFit = item;
maxScore = score;
}
else if (RenderingMode == RenderingMode.Inverted && score < maxScore)
{
bestFit = item;
maxScore = score;
}
}
return(bestFit);
}
//Add a decal to an image
public static PixelMatrix Decal(PixelMatrix original, PixelMatrix decal, int x, int y)
{
//Offsets to apply
int widthOffset = -decal.width / 2 + x;
int heightOffset = -decal.height / 2 + y;
for (int i = 0; i < decal.width; i++)
{
//X offset
int finalX = i + widthOffset;
//Skip column if out of original
if (finalX < 0 || finalX > original.width - 1)
{
continue;
}
for (int j = 0; j < decal.height; j++)
{
//Get color
Color cl = decal.GetPixelSafe(i, j);
//Skip transparent pixels
//TODO Blend with transparency?
if (cl.a < 0.7)
{
continue;
}
//Y offset
int finalY = j + heightOffset;
//Apply color
original.SetPixel(finalX, finalY, cl);
}
}
return(original);
}
/// <summary>
/// Calculates the best-fitting character based on the Euclidean distance between the character's and tile's histograms. See <see cref="RenderOption.CalculateCharForMatrix(PixelMatrix)"/> and <see cref="Histogram.EuclideanDistance(Histogram)"/> for more information.
/// </summary>
/// <param name="tile">The part of the image to be represented.</param>
/// <returns>The best-fitting character and its corresponding PixelMatrix.</returns>
public override KeyValuePair <char, PixelMatrix> CalculateCharForMatrix(PixelMatrix tile)
{
double maxScore = RenderingMode == RenderingMode.Default ? double.MinValue : double.MaxValue;
KeyValuePair <char, PixelMatrix> bestFit = Font.Chars.FirstOrDefault();
foreach (var item in Font.Chars)
{
double score = tile.Histogram.EuclideanDistance(item.Value.Histogram);
if (RenderingMode == RenderingMode.Default && score > maxScore)
{
bestFit = item;
maxScore = score;
}
else if (RenderingMode == RenderingMode.Inverted && score < maxScore)
{
bestFit = item;
maxScore = score;
}
}
return(bestFit);
}
public override void Compare(ByteWrapper image1, ByteWrapper image2)
{
var bm1 = new BitmapWrapper(ImageConvert.ReturnBitmap(image1.bytes));
bm1.sequenceNumber = logging.imagesReceived - 2;
var bm2 = new BitmapWrapper(ImageConvert.ReturnBitmap(image2.bytes));
bm2.sequenceNumber = logging.imagesReceived - 1;
PixelMatrix matrix = new PixelMatrix();
matrix.LinkCompare = settings.linkCompare;
if (settings.searchHeight > 0)
{
matrix.SearchHeight = settings.searchHeight;
}
if (settings.searchWidth > 0)
{
matrix.SearchWidth = settings.searchWidth;
}
if (settings.horizontalPixelsToSkip > 0)
{
matrix.WidthSearchOffset = settings.horizontalPixelsToSkip + 1;
}
if (settings.verticalPixelsToSkip > 0)
{
matrix.WidthSearchOffset = settings.verticalPixelsToSkip + 1;
}
if (settings.linkCompare && Comparison != null)
{
matrix.Populate(Comparison, bm2);
}
else
{
matrix.Populate(bm1, bm2);
}
double sumChangedPixels = matrix.SumChangedPixelsPositive;
//keep adding for threshold calculation, set the threshold, or monitor
if (ThresholdSet)
{
//now scanning, compare the two images and see what the difference is
if (sumChangedPixels > pixelChangeThreshold)
{
OnMotionAsync(image1, image2);
}
}
else if (!ThresholdSet && pixelChange.Count < ControlImageNumber)
{
pixelChange.Add(sumChangedPixels);
}
else
{
SetThreshold(); //enough images received to set the threshold and start monitoring
}
Comparison = matrix.Comparator;
if (logging.LoggingOn && logging.matrices != null)
{
logging.matrices.Add(matrix);
}
//clean up the memory
matrix.Dispose();
bm1.bitmap.Dispose();
bm2.bitmap.Dispose();
bm1 = null;
bm2 = null;
}//Compare
/// <summary>
/// Copies the pixel values to the output image. See <see cref="Converter{T}.AddToOutput(KeyValuePair{char, PixelMatrix}, Point, PixelMatrix)"/> for more information.
/// </summary>
/// <param name="character">The character to be drawn.</param>
/// <param name="point">A point that represents the coordinates of the upper left corner to be drawn.</param>
/// <param name="tile">The PixelMatrix representing a tile of the source image.</param>
protected override void AddToOutput(KeyValuePair <char, PixelMatrix> character, Point point, PixelMatrix tile)
{
for (int y = point.Y; y < point.Y + RenderOptions.TileSize.Height; y++)
{
for (int x = point.X * Utils.BytesPerPixel; x < (point.X + RenderOptions.TileSize.Width) * Utils.BytesPerPixel; x += Utils.BytesPerPixel)
{
int index = y * _size.Width * Utils.BytesPerPixel;
System.Drawing.Color c = DrawingMode.CalculateColor(character.Value.GetPixel(x - Utils.BytesPerPixel * point.X, y - point.Y), tile.GetPixel(x - Utils.BytesPerPixel * point.X, y - point.Y));
_pixels[index + x] = c.B; // b
_pixels[index + x + 1] = c.G; // g
_pixels[index + x + 2] = c.R; // r
_pixels[index + x + 3] = c.A; // a
}
}
}
public void LinqTesting()
{
try
{
List <int> dimensions = ReturnDimensions();
Stopwatch sw = new Stopwatch();
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"f:\temp\runtime\linqanalysis.txt", true))
{
for (int m = 0; m < dimensions.Count; m++)
{
for (int i = 0; i < 30; i++)
{
//do the minimum
BitmapWrapper bm1 = new BitmapWrapper(@"F:\temp\analysis\640x480\test_0.jpg");
BitmapWrapper bm2 = new BitmapWrapper(@"F:\temp\analysis\640x480\test_1.jpg");
PixelMatrix matrix = new PixelMatrix();
matrix.SearchWidth = dimensions[m];
matrix.Populate(bm1, bm2);
//LINQ
sw.Restart();
double min = matrix.MinChanged;
sw.Stop();
file.WriteLine("LINQ - min - " + m + " - " + sw.Elapsed.TotalMilliseconds);
sw.Restart();
double max = matrix.MaxChanged;
sw.Stop();
file.WriteLine("LINQ - max - " + m + " - " + sw.Elapsed.TotalMilliseconds);
sw.Restart();
double sum = matrix.SumChangedPixels;
sw.Stop();
file.WriteLine("LINQ - sum - " + m + " - " + sw.Elapsed.TotalMilliseconds);
//ITERATION
sw.Restart();
double min2 = 0;
for (int n = 0; n < matrix.Columns.Count; n++)
{
for (int k = 0; k < matrix.Columns[n].Cells.Count; k++)
{
if (matrix.Columns[n].Cells[k].change < min2)
{
min2 = matrix.Columns[n].Cells[k].change;
}
}
}
sw.Stop();
file.WriteLine("ITERATION - min - " + m + " - " + sw.Elapsed.TotalMilliseconds);
sw.Restart();
double max2 = 0;
for (int n = 0; n < matrix.Columns.Count; n++)
{
for (int k = 0; k < matrix.Columns[n].Cells.Count; k++)
{
if (matrix.Columns[n].Cells[k].change > max2)
{
max2 = matrix.Columns[n].Cells[k].change;
}
}
}
sw.Stop();
file.WriteLine("ITERATION - max - " + m + " - " + sw.Elapsed.TotalMilliseconds);
sw.Restart();
double sum2 = 0;
for (int n = 0; n < matrix.Columns.Count; n++)
{
for (int k = 0; k < matrix.Columns[n].Cells.Count; k++)
{
sum2 += matrix.Columns[n].Cells[k].change;
}
}
sw.Stop();
file.WriteLine("ITERATION - sum - " + m + " - " + sw.Elapsed.TotalMilliseconds);
}
}
}
Assert.IsTrue(true);
}
catch
{
Assert.IsTrue(false);
}
}
/// <summary> /// Calculates the best-fitting character for a part of the image. /// </summary> /// <param name="tile">The part of the image to be represented.</param> /// <returns>The best-fitting character and its corresponding PixelMatrix.</returns> public abstract KeyValuePair <char, PixelMatrix> CalculateCharForMatrix(PixelMatrix tile);
/// <summary>
/// Adds the character to the output string. See <see cref="Converter{T}.AddToOutput(KeyValuePair{char, PixelMatrix}, Point, PixelMatrix)"/> for more information.
/// </summary>
/// <param name="character">The character to be drawn.</param>
/// <param name="point">A point that represents the coordinates of the upper left corner to be drawn.</param>
/// <param name="tile">The PixelMatrix representing a tile of the source image.</param>
protected override void AddToOutput(KeyValuePair <char, PixelMatrix> character, Point point, PixelMatrix tile)
{
if (point.X == 0 && point.Y != 0)
{
_result.Append("\r\n");
}
_result.Append(character.Key);
}
/// <summary>
/// Adds the character to the output string. See <see cref="Converter{T}.AddToOutput(KeyValuePair{char, PixelMatrix}, Point, PixelMatrix)"/> for more information.
/// </summary>
/// <param name="character">The character to be drawn.</param>
/// <param name="point">A point that represents the coordinates of the upper left corner to be drawn.</param>
/// <param name="tile">The PixelMatrix representing a tile of the source image.</param>
protected override void AddToOutput(KeyValuePair <char, PixelMatrix> character, Point point, PixelMatrix tile)
{
if (point.X == 0 && point.Y != 0)
{
_result.Append("</p>");
}
Color c = DrawingMode.CalculateColor(Color.FromArgb(0), tile.AverageColor);
_result.Append(string.Format("<font color=\"{0:X2}{1:X2}{2:X2}\">{3}</font>", c.R, c.G, c.B, character.Key));
}
/// <summary> /// Adds the character at a specified position to the output. /// </summary> /// <param name="character">The character to be drawn.</param> /// <param name="point">A point that represents the coordinates of the upper left corner to be drawn.</param> /// <param name="tile">The PixelMatrix representing a tile of the source image.</param> protected abstract void AddToOutput(KeyValuePair <char, PixelMatrix> character, Point point, PixelMatrix tile);
public StandardImage(ColorModel.RGB[,] data)
{
// Set the pixel matrix
this.data = new PixelMatrix(data);
}
public PixelMatrix Test(PixelMatrix image)
{
var cut = new RotatePixelMatrix90degrees();
return(RunTest(image, cut));
}
public StandardImage(Bitmap image)
{
this.image = image;
// Read a the pixel data
this.data = new PixelMatrix(image.GetRGBPixelArray());
}
