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(); }