public static void RenderAllSpans(string edgeSpansPath, string imageFilePath, bool showDirections)
{
Log.Info($"Output image: {imageFilePath}");
if (showDirections)
{
Log.Info("Displaying span directions as well.");
}
using var spans = EdgeSpanStream.Load(edgeSpansPath);
using var timer = TimedOperation.Start("edge spans", totalWork: showDirections?spans.Count * 2 : spans.Count);
var scale = showDirections ? 3 : 1;
var resolution = spans.ViewPort.Resolution.Scale(scale);
var image = new FastImage(resolution);
image.Fill(Color.White);
Parallel.ForEach(spans, logicalSpan =>
{
if (showDirections)
{
var scaledLocation = logicalSpan.Location.Scale(scale);
for (int yDelta = 0; yDelta < 3; yDelta++)
{
for (int xDelta = 0; xDelta < 3; xDelta++)
{
image.SetPixel(
scaledLocation.OffsetBy(xDelta, yDelta),
(logicalSpan.Location.X + logicalSpan.Location.Y) % 2 == 1 ? Color.Black : Color.Gray);
}
}
}
else
{
image.SetPixel(
logicalSpan.Location,
Color.Black);
}
timer.AddWorkDone(1);
});
if (showDirections)
{
Parallel.ForEach(spans, locatedSpan =>
{
var scaledLocation = locatedSpan.Location.Scale(scale);
var pointingTo = scaledLocation.OffsetBy(1, 1).OffsetIn(locatedSpan.ToOutside);
image.SetPixel(
pointingTo,
Color.Red);
timer.AddWorkDone(1);
});
}
image.Save(imageFilePath);
}
public static void Render(string pointFilePath, Size?resolution)
{
using var points = PointStream.Load(pointFilePath);
var viewPort = points.ViewPort;
var actualResolution = resolution ?? points.ViewPort.Resolution;
if (actualResolution != points.ViewPort.Resolution)
{
viewPort = new ViewPort(viewPort.Area, actualResolution);
}
var imageFilePath = pointFilePath + $".{actualResolution.Width}x{actualResolution.Height}.png";
using var timer = TimedOperation.Start("points", totalWork: actualResolution.Area());
var image = new FastImage(actualResolution);
image.Fill(Color.White);
Parallel.ForEach(points, point =>
{
image.SetPixel(viewPort.GetPosition(point), Color.Black);
timer.AddWorkDone(1);
});
image.Save(imageFilePath);
}
private void Fts()
{
for (var row = 1; row <= image.Height - 2; row++)
{
for (var col = 1; col <= image.Width - 2; col++)
{
int sR = 0, sG = 0, sB = 0;
Color color;
for (var _col = col - 1; _col <= col + 1; _col++)
{
for (var _row = row - 1; _row <= row + 1; _row++)
{
var _point = new Point {
X = _col, Y = _row
};
color = image.GetPixel(_point);
sR += (int)(color.R * H[_row - row + 1, _col - col + 1]);
sG += (int)(color.G * H[_row - row + 1, _col - col + 1]);
sB += (int)(color.B * H[_row - row + 1, _col - col + 1]);
}
}
var point = new Point {
X = col, Y = row
};
sR = Utils.ClampByte(sR);
sG = Utils.ClampByte(sG);
sB = Utils.ClampByte(sB);
color = Color.FromArgb(sR, sG, sB);
image.SetPixel(point, color);
}
}
}
public static void Laplace(FastImage fastImage, FastImage originalFastImage)
{
var H1 = new[, ]
{
{ 0, 1, 0 },
{ 1, -4, 1 },
{ 0, 1, 0 }
};
var H2 = new[, ]
{
{ -1, -1, -1 },
{ -1, 8, -1 },
{ -1, -1, -1 }
};
fastImage.Lock();
originalFastImage.Lock();
for (int row = 1; row < originalFastImage.Width - 2; row++)
{
for (int column = 1; column < originalFastImage.Height - 2; column++)
{
GetConvolutionSums(originalFastImage, row, column, H1, out var sumRedH1, out var sumGreenH1, out var sumBlueH1);
GetConvolutionSums(originalFastImage, row, column, H2, out var sumRedH2, out var sumGreenH2, out var sumBlueH2);
var sumsRed = new List <int> {
sumRedH1, sumRedH2
};
var sumsGreen = new List <int> {
sumGreenH1, sumGreenH2
};
var sumsBlue = new List <int> {
sumBlueH1, sumBlueH2
};
var maxRed = sumsRed.Max();
var maxGreen = sumsGreen.Max();
var maxBlue = sumsBlue.Max();
maxRed = Normalizare(maxRed, 0, 255);
maxGreen = Normalizare(maxGreen, 0, 255);
maxBlue = Normalizare(maxBlue, 0, 255);
var newColor = Color.FromArgb(maxRed, maxGreen, maxBlue);
fastImage.SetPixel(row, column, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void Export(MetaMap map, MapPalette palette, string outputFilePath, int scale = 1)
{
using var image = new FastImage(map.Width, map.Height, scale);
for (var tileY = 0; tileY < map.Height; tileY++)
{
for (var tileX = 0; tileX < map.Width; tileX++)
{
var tileColor = palette.PickColor(map[tileX, tileY]);
image.SetPixel(tileX, tileY, tileColor);
}
}
image.Save(outputFilePath);
}
private void DoKirsch()
{
for (var row = 1; row <= image.Height - 2; row++)
{
for (var col = 1; col <= image.Width - 2; col++)
{
var point = new Point {
X = col, Y = row
};
var color = GetColorFromPoint(point);
image.SetPixel(point, color);
}
}
}
public static IFastImage Render(LightMap lightMap, int scale = 10)
{
var image = new FastImage(lightMap.Size.Width, lightMap.Size.Height, scale);
for (int y = 0; y < lightMap.Size.Height; y++)
{
for (int x = 0; x < lightMap.Size.Width; x++)
{
var light = lightMap[x, y];
byte intensity = (byte)((((double)light + lightMap.Range.DarkLevels) / lightMap.Range.Total) * 256);
image.SetPixel(x, y, new SKColor(intensity, intensity, intensity));
}
}
return(image);
}
private void CBPF()
{
for (int y = 0; y < image.Width; y++)
{
for (int x = 0; x < image.Height; x++)
{
var point = new Point {
X = x, Y = y
};
if (SaltAndPepper(point))
{
var result = CBP(point);
image.SetPixel(point, result);
}
}
}
}
public static void LowPassFiler(FastImage fastImage, FastImage originalFastImage, int n)
{
if (n < 1)
{
throw new ArgumentException();
}
var matrix = GetLowPassFilterMatrix(n);
fastImage.Lock();
originalFastImage.Lock();
for (int row = 1; row < originalFastImage.Width - 2; row++)
{
for (int column = 1; column < originalFastImage.Height - 2; column++)
{
var sumRed = 0;
var sumGreen = 0;
var sumBlue = 0;
for (int i = row - 1; i <= row + 1; i++)
{
for (int j = column - 1; j <= column + 1; j++)
{
var pixel = originalFastImage.GetPixel(i, j);
sumRed += pixel.R * matrix[i - row + 1, j - column + 1];
sumGreen += pixel.G * matrix[i - row + 1, j - column + 1];
sumBlue += pixel.B * matrix[i - row + 1, j - column + 1];
}
}
var divide = (n + 2) * (n + 2);
var newRed = sumRed / divide;
var newGreen = sumGreen / divide;
var newBlue = sumBlue / divide;
var newColor = Color.FromArgb(newRed, newGreen, newBlue);
fastImage.SetPixel(row, column, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void GrayScaleFastImage(FastImage fastImage)
{
fastImage.Lock();
for (var i = 0; i < fastImage.Width; i++)
{
for (var j = 0; j < fastImage.Height; j++)
{
var color = fastImage.GetPixel(i, j);
var average = (byte)((color.R + color.G + color.B) / 3);
color = Color.FromArgb(average, average, average);
fastImage.SetPixel(i, j, color);
}
}
fastImage.Unlock();
}
public static void Sobel(FastImage fastImage, FastImage originalFastImage)
{
var P = new[, ]
{
{ -1, -2, -1 },
{ 0, 0, 0 },
{ 1, 2, 1 }
};
var Q = new[, ]
{
{ -1, 0, 1 },
{ -2, 0, 2 },
{ -1, 0, 1 }
};
fastImage.Lock();
originalFastImage.Lock();
for (int row = 1; row < originalFastImage.Width - 2; row++)
{
for (int column = 1; column < originalFastImage.Height - 2; column++)
{
GetConvolutionSums(originalFastImage, row, column, P, out var sumRedP, out var sumGreenP, out var sumBlueP);
GetConvolutionSums(originalFastImage, row, column, Q, out var sumRedQ, out var sumGreenQ, out var sumBlueQ);
var maxRed = (int)Math.Sqrt(Math.Pow(sumRedP, 2) + Math.Pow(sumRedQ, 2));
var maxGreen = (int)Math.Sqrt(Math.Pow(sumGreenP, 2) + Math.Pow(sumGreenQ, 2));
var maxBlue = (int)Math.Sqrt(Math.Pow(sumBlueP, 2) + Math.Pow(sumBlueQ, 2));
maxRed = Normalizare(maxRed, 0, 255);
maxGreen = Normalizare(maxGreen, 0, 255);
maxBlue = Normalizare(maxBlue, 0, 255);
var newColor = Color.FromArgb(maxRed, maxGreen, maxBlue);
fastImage.SetPixel(row, column, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void Roberts(FastImage fastImage, FastImage originalFastImage)
{
var P = new[, ]
{
{ -1, 0 },
{ 0, 1 },
};
var Q = new[, ]
{
{ 0, 1 },
{ -1, 0 },
};
fastImage.Lock();
originalFastImage.Lock();
const int k = 7;
for (int row = 1; row < originalFastImage.Width - 2; row++)
{
for (int column = 1; column < originalFastImage.Height - 2; column++)
{
GetConvolutionSumsForRobert(originalFastImage, row, column, P, out var sumRedP, out var sumGreenP, out var sumBlueP);
GetConvolutionSumsForRobert(originalFastImage, row, column, Q, out var sumRedQ, out var sumGreenQ, out var sumBlueQ);
int newRed = k * (int)Math.Sqrt(Math.Pow(sumRedP, 2) + Math.Pow(sumRedQ, 2));
int newGreen = k * (int)Math.Sqrt(Math.Pow(sumGreenP, 2) + Math.Pow(sumGreenQ, 2));
int newBlue = k * (int)Math.Sqrt(Math.Pow(sumBlueP, 2) + Math.Pow(sumBlueQ, 2));
newRed = Normalizare(newRed, 0, 255);
newGreen = Normalizare(newGreen, 0, 255);
newBlue = Normalizare(newBlue, 0, 255);
var newColor = Color.FromArgb(newRed, newGreen, newBlue);
fastImage.SetPixel(row, column, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void CBPF(FastImage fastImage, FastImage originalFastImage, int contextSize, int searchRadius, int sumLimit)
{
fastImage.Lock();
originalFastImage.Lock();
for (int i = 0; i < originalFastImage.Width; i++)
{
for (int j = 0; j < originalFastImage.Height; j++)
{
if (SaltPepper(originalFastImage, i, j))
{
var newColor = CBP(originalFastImage, i, j, contextSize, searchRadius, sumLimit);
fastImage.SetPixel(i, j, Color.FromArgb(newColor, newColor, newColor));
}
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
private void DOSmth()
{
for (var row = 1; row <= image.Height - 2; row++)
{
for (var col = 1; col <= image.Width - 2; col++)
{
var point = new Point {
X = col, Y = row
};
var colorFtj = getFTJ(point);
var color = image.GetPixel(point);
var r = ComputeNewPixelColor(color.R, colorFtj.R);
var g = ComputeNewPixelColor(color.G, colorFtj.G);
var b = ComputeNewPixelColor(color.B, colorFtj.B);
var newColor = Color.FromArgb(r, g, b);
// var newColor = Color.FromArgb(colorFtj.R, colorFtj.G, colorFtj.B);
image.SetPixel(point, newColor);
}
}
}
public static void NegateFastImage(FastImage fastImage)
{
fastImage.Lock();
for (var i = 0; i < fastImage.Width; i++)
{
for (var j = 0; j < fastImage.Height; j++)
{
var color = fastImage.GetPixel(i, j);
var newRed = (byte)(255 - color.R);
var newGreen = (byte)(255 - color.G);
var newBlue = (byte)(255 - color.B);
color = Color.FromArgb(newRed, newGreen, newBlue);
fastImage.SetPixel(i, j, color);
}
}
fastImage.Unlock();
}
public System.Drawing.Bitmap GetAsBitmap()
{
GR.Image.FastImage fastImage = new FastImage(Width, Height, PixelFormat);
for (int i = 0; i < PaletteEntryCount; ++i)
{
fastImage.SetPaletteColor(i, PaletteRed(i), PaletteGreen(i), PaletteBlue(i));
}
for (int x = 0; x < Width; ++x)
{
for (int y = 0; y < Height; ++y)
{
fastImage.SetPixel(x, y, GetPixel(x, y));
}
}
System.Drawing.Bitmap bitmap = fastImage.GetAsBitmap();
fastImage.Dispose();
return(bitmap);
}
public static void ApplyEqualization(FastImage fastImage, FastImage originalFastImage)
{
var oldGrayScaleHistogram = originalFastImage.GrayScaleHistogram;
var newGrayScaleHistogram = new int[256];
newGrayScaleHistogram[0] = oldGrayScaleHistogram[0];
for (var i = 1; i < oldGrayScaleHistogram.Length; i++)
{
newGrayScaleHistogram[i] = newGrayScaleHistogram[i - 1] + oldGrayScaleHistogram[i];
}
var transf = new int[256];
for (var i = 0; i < transf.Length; i++)
{
transf[i] = (newGrayScaleHistogram[i] * 255) / (originalFastImage.Width * originalFastImage.Height);
}
originalFastImage.Lock();
fastImage.Lock();
for (var i = 0; i < fastImage.Width; i++)
{
for (var j = 0; j < fastImage.Height; j++)
{
var color = originalFastImage.GetPixel(i, j);
var gray = (color.R + color.G + color.B) / 3;
var newColor = Color.FromArgb(transf[gray], transf[gray], transf[gray]);
fastImage.SetPixel(i, j, newColor);
}
}
originalFastImage.Unlock();
fastImage.Unlock();
}
public static void Render(string gridFilePath, string imageFilePath)
{
Log.Info($"Output image: {imageFilePath}");
using var grid = PointGrid.Load(gridFilePath);
using var timer = TimedOperation.Start("points", totalWork: grid.ViewPort.Resolution.Area());
var image = new FastImage(grid.ViewPort.Resolution);
image.Fill(Color.White);
Parallel.ForEach(grid, row =>
{
foreach (var setSegment in row.GetSegmentsInSet())
{
foreach (var x in Enumerable.Range(setSegment.StartCol, setSegment.Length))
{
image.SetPixel(x, row.Y, Color.Black);
}
}
timer.AddWorkDone(grid.ViewPort.Resolution.Width);
});
image.Save(imageFilePath);
}
public static void RenderSingleSpan(string edgeSpansPath, int spanIndex, int sideResolution)
{
var resolution = new Size(sideResolution, sideResolution);
using var spans = EdgeSpanStream.Load(edgeSpansPath);
using var timer = TimedOperation.Start("points", totalWork: resolution.Area());
var random = new Random();
var index = spanIndex >= 0 ? spanIndex : random.Next(0, spans.Count);
var imageFilePath = Path.Combine(
Path.GetDirectoryName(edgeSpansPath) ?? throw new Exception($"Could not get directory name: {edgeSpansPath}"),
Path.GetFileNameWithoutExtension(edgeSpansPath) + $"_{index}_{sideResolution}x{sideResolution}.png");
Log.Info($"Using edge span index {index:N0}");
Log.Info($"Output file: {imageFilePath}");
var span = spans.ElementAt(index).ToConcreteDouble(spans.ViewPort);
var spanLength = span.Length();
Log.Info($"Edge span: {span} (length: {spanLength})");
var image = new FastImage(resolution);
var viewPort = new ViewPort(GetArea(span), resolution);
Log.Info($"View port: {viewPort}");
var positionInSet = viewPort.GetPosition(span.InSet);
var positionNotInSet = viewPort.GetPosition(span.NotInSet);
var highlightPixelRadius = resolution.Width / 100;
var borderPoint = span.FindBoundaryPoint(Constant.IterationRange.Max);
Log.Info($"Border point: {borderPoint} (escape time: {ScalarDoubleKernel.FindEscapeTime(borderPoint)})");
var borderPointPosition = viewPort.GetPosition(borderPoint);
// TODO: Why is the inner loop parallelized?
for (int row = 0; row < resolution.Height; row++)
{
Parallel.For(0, resolution.Width,
col =>
{
var position = new Point(col, row);
var c = viewPort.GetComplex(position);
Color PickColor()
{
if (position.DistanceSquaredFrom(positionInSet) <= highlightPixelRadius)
{
return(Color.Red);
}
if (position.DistanceSquaredFrom(positionNotInSet) <= highlightPixelRadius)
{
return(Color.ForestGreen);
}
if (position.DistanceSquaredFrom(borderPointPosition) <= highlightPixelRadius)
{
return(Color.Fuchsia);
}
var isInSet = ScalarDoubleKernel.FindEscapeTime(c, Constant.IterationRange.Max).IsInfinite;
return(isInSet ? Color.FromArgb(0x20, 0x20, 0x20) : Color.White);
}
image.SetPixel(position, PickColor());
});
timer.AddWorkDone(resolution.Width);
}
image.Save(imageFilePath);
}
public Bitmap Compute(Point point)
{
image.Lock();
canvas.Lock();
pointsQueue.Enqueue(point);
sumaIntensitati += Utils.GetGrayscale(image.GetPixel(point));
contor++;
while (pointsQueue.Count > 0)
{
var selectedPoint = pointsQueue.Peek();
if (matriceVizitate[selectedPoint.X, selectedPoint.Y])
{
pointsQueue.Dequeue();
continue;
}
var limitXmin = selectedPoint.X == 0 ? selectedPoint.X : selectedPoint.X - 1;
var limitXmax = selectedPoint.X == image.Width - 1 ? selectedPoint.X : selectedPoint.X + 1;
var limitYmin = selectedPoint.Y == 0 ? 0 : selectedPoint.Y - 1;
var limitYmax = selectedPoint.Y == image.Height - 1 ? selectedPoint.Y : selectedPoint.Y + 1;
var pointA = new Point {
X = limitXmin, Y = limitYmin
};
var pointB = new Point {
X = limitXmax, Y = limitYmin
};
var pointC = new Point {
X = limitXmin, Y = limitYmax
};
var pointD = new Point {
X = limitXmax, Y = limitYmax
};
var culoareA = image.GetPixel(pointA);
var culoareB = image.GetPixel(pointB);
var culoareC = image.GetPixel(pointC);
var culoareD = image.GetPixel(pointD);
if (Math.Abs(Utils.GetGrayscale(culoareA) - mediaIntensitati) < prag)
{
pointsQueue.Enqueue(pointA);
}
if (Math.Abs(Utils.GetGrayscale(culoareB) - mediaIntensitati) < prag)
{
pointsQueue.Enqueue(pointB);
}
if (Math.Abs(Utils.GetGrayscale(culoareB) - mediaIntensitati) < prag)
{
pointsQueue.Enqueue(pointC);
}
if (Math.Abs(Utils.GetGrayscale(culoareB) - mediaIntensitati) < prag)
{
pointsQueue.Enqueue(pointD);
}
sumaIntensitati += Utils.GetGrayscale(image.GetPixel(point));
contor++;
matriceVizitate[selectedPoint.X, selectedPoint.Y] = true;
canvas.SetPixel(selectedPoint, image.GetPixel(selectedPoint));
pointsQueue.Dequeue();
}
image.Unlock();
canvas.Unlock();
return(canvas.GetBitMap());
}
public static void HighPassFilter(FastImage fastImage, FastImage originalFastImage)
{
int[,] H =
{
{ 0, -1, 0 },
{ -1, 5, -1 },
{ 0, -1, 0 }
};
fastImage.Lock();
originalFastImage.Lock();
for (int i = 1; i <= fastImage.Width - 2; i++)
{
for (int j = 1; j <= fastImage.Height - 2; j++)
{
var sumaR = 0;
var sumaG = 0;
var sumaB = 0;
Color color;
for (int row = i - 1; row <= i + 1; row++)
{
for (int col = j - 1; col <= j + 1; col++)
{
color = originalFastImage.GetPixel(row, col);
int R = color.R;
int G = color.G;
int B = color.B;
sumaR += R * H[row - i + 1, col - j + 1];
sumaG += G * H[row - i + 1, col - j + 1];
sumaB += B * H[row - i + 1, col - j + 1];
}
}
if (sumaR > 255)
{
sumaR = 255;
}
if (sumaR < 0)
{
sumaR = 0;
}
if (sumaG > 255)
{
sumaG = 255;
}
if (sumaG < 0)
{
sumaG = 0;
}
if (sumaB > 255)
{
sumaB = 255;
}
if (sumaB < 0)
{
sumaB = 0;
}
color = Color.FromArgb(sumaR, sumaG, sumaB);
fastImage.SetPixel(i, j, color);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void FreiChen(FastImage fastImage, FastImage originalFastImage)
{
var matrixes = new List <double[, ]>();
var radical2 = Math.Sqrt(2);
//F1
matrixes.Add(new double[, ]
{
{ 1, radical2, 1 },
{ 0, 0, 0 },
{ -1, -radical2, -1 }
});
// F2
matrixes.Add(new double[, ]
{
{ 1, 0, -1 },
{ radical2, 0, -radical2 },
{ 1, 0, -1 }
});
// F3
matrixes.Add(new double[, ]
{
{ 0, -1, radical2 },
{ 1, 0, -1 },
{ -radical2, 1, 0 }
});
// F4
matrixes.Add(new double[, ]
{
{ radical2, -1, 0 },
{ -1, 0, 1 },
{ 0, 1, -radical2 }
});
// F5
matrixes.Add(new double[, ]
{
{ 0, 1, 0 },
{ -1, 0, -1 },
{ 0, 1, 0 }
});
// F6
matrixes.Add(new double[, ]
{
{ -1, 0, 1 },
{ 0, 0, 0 },
{ 1, 0, -1 }
});
// F7
matrixes.Add(new double[, ]
{
{ 1, -2, 1 },
{ -2, 4, -2 },
{ 1, -2, 1 }
});
// F8
matrixes.Add(new double[, ]
{
{ -2, 1, -2 },
{ 1, 4, 1 },
{ -2, 1, -2 }
});
// F9
matrixes.Add(new double[, ]
{
{ 1d / 9, 1d / 9, 1d / 9 },
{ 1d / 9, 1d / 9, 1d / 9 },
{ 1d / 9, 1d / 9, 1d / 9 }
});
fastImage.Lock();
originalFastImage.Lock();
for (int row = 1; row < originalFastImage.Width - 2; row++)
{
for (int column = 1; column < originalFastImage.Height - 2; column++)
{
GetConvolutionSumsForFreiChen(originalFastImage, row, column, matrixes, out var sumRed, out var sumGreen, out var sumBlue);
sumRed = Normalizare(sumRed, 0, 255);
sumGreen = Normalizare(sumGreen, 0, 255);
sumBlue = Normalizare(sumBlue, 0, 255);
var newColor = Color.FromArgb(sumRed, sumGreen, sumBlue);
fastImage.SetPixel(row, column, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void Unsharp(FastImage fastImage, FastImage originalFastImage)
{
int[,] H = { { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 } };
double c = 0.6;
fastImage.Lock();
originalFastImage.Lock();
for (int i = 1; i < fastImage.Width - 2; i++)
{
for (int j = 1; j < fastImage.Height - 2; j++)
{
double sumR = 0;
double sumG = 0;
double sumB = 0;
double SumaR0 = 0;
double SumaG0 = 0;
double SumaB0 = 0;
double R = 0;
double G = 0;
double B = 0;
Color color;
for (int row = i - 1; row <= i + 1; row++)
{
for (int col = j - 1; col <= j + 1; col++)
{
color = originalFastImage.GetPixel(row, col);
R = color.R;
G = color.G;
B = color.B;
sumR = sumR + R * H[row - i + 1, col - j + 1];
sumG = sumG + G * H[row - i + 1, col - j + 1];
sumB = sumB + B * H[row - i + 1, col - j + 1];
}
}
sumR /= (1 + 2) * (1 + 2);
sumG /= (1 + 2) * (1 + 2);
sumB /= (1 + 2) * (1 + 2);
SumaR0 = (c / (1.2 - 1.0)) * R - ((1.0 - c) / (1.2 - 1.0)) * sumR;
SumaG0 = (c / (1.2 - 1.0)) * G - ((1.0 - c) / (1.2 - 1.0)) * sumG;
SumaB0 = (c / (1.2 - 1.0)) * B - ((1.0 - c) / (1.2 - 1.0)) * sumB;
if (SumaR0 > 255)
{
SumaR0 = 255;
}
if (SumaR0 < 0)
{
SumaR0 = 0;
}
if (SumaG0 > 255)
{
SumaG0 = 255;
}
if (SumaG0 < 0)
{
SumaG0 = 0;
}
if (SumaB0 > 255)
{
SumaB0 = 255;
}
if (SumaB0 < 0)
{
SumaB0 = 0;
}
color = Color.FromArgb((int)SumaR0, (int)SumaG0, (int)SumaB0);
fastImage.SetPixel(i, j, color);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void ChangeIntensityForFastImage(FastImage fastImage, FastImage originalFastImage, int intensity)
{
fastImage.Lock();
originalFastImage.Lock();
var minR = originalFastImage.RedMinimumValue;
var maxR = originalFastImage.RedMaximumValue;
var minG = originalFastImage.GreenMinimumValue;
var maxG = originalFastImage.GreenMaximumValue;
var minB = originalFastImage.BlueMinimumValue;
var maxB = originalFastImage.BlueMaximumValue;
var redA = GetA(minR, intensity);
var redB = GetB(maxR, intensity);
var greenA = GetA(minG, intensity);
var greenB = GetB(maxG, intensity);
var blueA = GetA(minB, intensity);
var blueB = GetB(maxB, intensity);
for (var i = 0; i < originalFastImage.Width; i++)
{
for (var j = 0; j < originalFastImage.Height; j++)
{
var oldRed = originalFastImage.GetPixel(i, j).R;
var newRed = (redB - redA) * (oldRed - minR) / (maxR - minR) + redA;
var oldGreen = originalFastImage.GetPixel(i, j).G;
var newGreen = (greenB - greenA) * (oldGreen - minG) / (maxG - minG) + greenA;
var oldBlue = originalFastImage.GetPixel(i, j).B;
var newBlue = (blueB - blueA) * (oldBlue - minB) / (maxB - minB) + blueA;
if (newRed > 255)
{
newRed = 255;
}
else if (newRed < 0)
{
newRed = 0;
}
if (newGreen > 255)
{
newGreen = 255;
}
else if (newGreen < 0)
{
newGreen = 0;
}
if (newBlue > 255)
{
newBlue = 255;
}
else if (newBlue < 0)
{
newBlue = 0;
}
var newColor = Color.FromArgb(newRed, newGreen, newBlue);
fastImage.SetPixel(i, j, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
