public Maybe<Image> TryTransform()
{
try
{
using (var sourceLockbitImage = new WritableLockBitImage(_sourceImage))
using (var outputLockbitImage = new WritableLockBitImage(_sourceImage.Width, _sourceImage.Height))
{
// Get boxes
int index = 0;
foreach (int boxWidth in this.EnumerateBoxesForGauss(_radius, 3))
{
if (index % 2 == 0)
{
PerformSplitBoxBlurAcc(sourceLockbitImage, outputLockbitImage, (boxWidth - 1) / 2);
}
else
{
PerformSplitBoxBlurAcc(outputLockbitImage, sourceLockbitImage, (boxWidth - 1) / 2);
}
index++;
}
outputLockbitImage.Lock();
return outputLockbitImage.GetImage().ToMaybe();
}
}
catch (Exception)
{
}
return Maybe<Image>.Nothing;
}
public static void CopyPixels(this IBoxBlur _, WritableLockBitImage sourceImage, WritableLockBitImage destImage)
{
for (int row = 0; row < sourceImage.Height; row++)
{
for (int col = 0; col < sourceImage.Width; col++)
{
destImage.SetPixel(col, row, sourceImage.GetPixel(col, row));
}
}
}
private static void PerformHorizontalBoxBlurAcc(WritableLockBitImage sourceImage, WritableLockBitImage outputImage, int radius)
{
double iarr = 1 / ((double)radius + radius + 1);
for (int row = 0; row < sourceImage.Height; row++)
{
Color firstPixel = sourceImage.GetPixel(0, row);
Color lastPixel = sourceImage.GetPixel(sourceImage.Width - 1, row);
int cumRedValue = (radius + 1) * firstPixel.R;
int cumGreenValue = (radius + 1) * firstPixel.G;
int cumBlueValue = (radius + 1) * firstPixel.B;
int currentLastColIndex = 0; // li
int currentRadiusColIndex = radius; // ri
for (int col = 0; col < radius; col++)
{
Color chosenPixel = sourceImage.GetPixel(col, row);
cumRedValue += chosenPixel.R;
cumGreenValue += chosenPixel.G;
cumBlueValue += chosenPixel.B;
}
for (int col = 0; col <= radius; col++)
{
Color chosenPixel = sourceImage.GetPixel(currentRadiusColIndex, row);
cumRedValue += chosenPixel.R - firstPixel.R;
cumGreenValue += chosenPixel.G - firstPixel.G;
cumBlueValue += chosenPixel.B - firstPixel.B;
currentRadiusColIndex++;
outputImage.SetPixel(
col,
row,
Color.FromArgb(
(int)Math.Round(cumRedValue * iarr),
(int)Math.Round(cumGreenValue * iarr),
(int)Math.Round(cumBlueValue * iarr)
)
);
}
for (int col = radius + 1; col < sourceImage.Width - radius; col++)
{
Color chosenRadiusPixel = sourceImage.GetPixel(currentRadiusColIndex, row);
Color chosenLastPixel = sourceImage.GetPixel(currentLastColIndex, row);
cumRedValue += chosenRadiusPixel.R - chosenLastPixel.R;
cumGreenValue += chosenRadiusPixel.G - chosenLastPixel.G;
cumBlueValue += chosenRadiusPixel.B - chosenLastPixel.B;
currentRadiusColIndex++;
currentLastColIndex++;
outputImage.SetPixel(
col,
row,
Color.FromArgb(
(int)Math.Round(cumRedValue * iarr),
(int)Math.Round(cumGreenValue * iarr),
(int)Math.Round(cumBlueValue * iarr)
)
);
}
for (int col = sourceImage.Width - radius; col < sourceImage.Width; col++)
{
Color chosenLastPixel = sourceImage.GetPixel(currentLastColIndex, row);
cumRedValue += lastPixel.R - chosenLastPixel.R;
cumGreenValue += lastPixel.G - chosenLastPixel.G;
cumBlueValue += lastPixel.B - chosenLastPixel.B;
currentLastColIndex++;
outputImage.SetPixel(
col,
row,
Color.FromArgb(
(int)Math.Round(cumRedValue * iarr),
(int)Math.Round(cumGreenValue * iarr),
(int)Math.Round(cumBlueValue * iarr)
)
);
}
}
}
private void PerformSplitBoxBlurAcc(WritableLockBitImage sourceImage, WritableLockBitImage outputImage, int radius)
{
// Copy pixels from source to output
this.CopyPixels(sourceImage, outputImage);
// The switching of outputImage and souceImage is INTENTIONAL!
PerformHorizontalBoxBlurAcc(outputImage, sourceImage, radius);
PerformTotalBoxBlurAcc(sourceImage, outputImage, radius);
}
private static void PerformTotalBoxBlurAcc(WritableLockBitImage sourceImage, WritableLockBitImage outputImage, int radius)
{
double iarr = 1 / ((double)radius + radius + 1);
for (int col = 0; col < sourceImage.Width; col++)
{
Color topPixel = sourceImage.GetPixel(col, 0);
Color bottomPixel = sourceImage.GetPixel(col, sourceImage.Height - 1);
int cumRedValue = (radius + 1) * topPixel.R;
int cumGreenValue = (radius + 1) * topPixel.G;
int cumBlueValue = (radius + 1) * topPixel.B;
for (int row = 0; row < radius; row++)
{
Color chosenPixel = sourceImage.GetPixel(col, row);
cumRedValue += chosenPixel.R;
cumGreenValue += chosenPixel.G;
cumBlueValue += chosenPixel.B;
}
for (int row = 0; row <= radius; row++)
{
Color chosenPixel = sourceImage.GetPixel(col, row + radius);
cumRedValue += chosenPixel.R - topPixel.R;
cumGreenValue += chosenPixel.G - topPixel.G;
cumBlueValue += chosenPixel.B - topPixel.B;
outputImage.SetPixel(
col,
row,
Color.FromArgb(
(int)Math.Round(cumRedValue * iarr),
(int)Math.Round(cumGreenValue * iarr),
(int)Math.Round(cumBlueValue * iarr)
)
);
}
for (int row = radius + 1; row < sourceImage.Height - radius; row++)
{
Color radiusPixel = sourceImage.GetPixel(col, radius + row);
Color laggingPixel = sourceImage.GetPixel(col, row - radius - 1);
cumRedValue += radiusPixel.R - laggingPixel.R;
cumGreenValue += radiusPixel.G - laggingPixel.G;
cumBlueValue += radiusPixel.B - laggingPixel.B;
outputImage.SetPixel(
col,
row,
Color.FromArgb(
(int)Math.Round(cumRedValue * iarr),
(int)Math.Round(cumGreenValue * iarr),
(int)Math.Round(cumBlueValue * iarr)
)
);
}
for (int row = sourceImage.Height - radius; row < sourceImage.Height; row++)
{
Color laggingPixel = sourceImage.GetPixel(col, row - radius);
cumRedValue += bottomPixel.R - laggingPixel.R;
cumGreenValue += bottomPixel.G - laggingPixel.G;
cumBlueValue += bottomPixel.B - laggingPixel.B;
outputImage.SetPixel(
col,
row,
Color.FromArgb(
(int)Math.Round(cumRedValue * iarr),
(int)Math.Round(cumGreenValue * iarr),
(int)Math.Round(cumBlueValue * iarr)
)
);
}
}
}
private static void PerformHorizontalBoxBlur(WritableLockBitImage sourceImage, WritableLockBitImage outputImage, int radius)
{
double valueDivisor = radius + radius + 1;
for (int row = 0; row < sourceImage.Height; row++)
{
for (int col = 0; col < sourceImage.Width; col++)
{
int totalValueRed = 0, totalValueGreen = 0, totalValueBlue = 0;
for (int colIndex = col - radius; colIndex < col + radius + 1; colIndex++)
{
int chosenCol = Math.Min(sourceImage.Width - 1, Math.Max(0, colIndex));
Color chosenPixel = sourceImage.GetPixel(chosenCol, row);
totalValueRed += chosenPixel.R;
totalValueGreen += chosenPixel.G;
totalValueBlue += chosenPixel.B;
}
outputImage.SetPixel(col, row, Color.FromArgb(
(int)Math.Round(totalValueRed / valueDivisor),
(int)Math.Round(totalValueGreen / valueDivisor),
(int)Math.Round(totalValueBlue / valueDivisor)
));
}
}
}
private static void BoxBlurForGaussianBlurHelper(WritableLockBitImage inputImage, WritableLockBitImage outputImage, int radius)
{
double radiusDivisor = (radius + radius + 1) * (radius + radius + 1);
for (int row = 0; row < inputImage.Height; row++)
{
for (int col = 0; col < inputImage.Width; col++)
{
int cumulativeSourceRedValue = 0,
cumulativeSourceGreenValue = 0,
cumulativeSourceBlueValue = 0;
for (int rowIndex = row - radius; rowIndex < row + radius + 1; rowIndex++)
{
for (int colIndex = col - radius; colIndex < col + radius + 1; colIndex++)
{
int chosenRow = Math.Min(inputImage.Height - 1, Math.Max(0, rowIndex));
int chosenCol = Math.Min(inputImage.Width - 1, Math.Max(0, colIndex));
Color chosenPixel = inputImage.GetPixel(chosenCol, chosenRow);
cumulativeSourceRedValue += chosenPixel.R;
cumulativeSourceGreenValue += chosenPixel.G;
cumulativeSourceBlueValue += chosenPixel.B;
}
}
Color bluredColor = Color.FromArgb(
(int)Math.Round(cumulativeSourceRedValue / radiusDivisor),
(int)Math.Round(cumulativeSourceGreenValue / radiusDivisor),
(int)Math.Round(cumulativeSourceBlueValue / radiusDivisor)
);
outputImage.SetPixel(col, row, bluredColor);
}
}
}
public Maybe<Image> TryTransform()
{
try
{
// Output color matrix
using (var outputBitmap = new WritableLockBitImage(_sourceImage.Width, _sourceImage.Height))
{
// Setting up some constants up here
double exponentDenominator = 2 * _radius * _radius;
double gaussianWeightDenominator = exponentDenominator * Math.PI;
int radiusEffectiveRange = (int)Math.Ceiling(_radius * GAUSSIAN_RADIUS_RANGE);
// Go through every single pixel
for (int row = 0; row < _sourceImage.Height; row++)
{
for (int col = 0; col < _sourceImage.Width; col++)
{
// Calculate the weighted sum of all of the neighboring pixels,
// governed by the radiusEffectiveRange variable above, and take
// the average value and then set it to the value of whatever
// pixel is at (row, col)
double neighborhoodRedPixelWeightedSum = 0,
neighborhoodGreenPixelWeightedSum = 0,
neighborhoodBluePixelWeightedSum = 0,
sumOfGaussianValues = 0;
for (
int neighboringPixelRow = row - radiusEffectiveRange;
neighboringPixelRow <= row + radiusEffectiveRange;
neighboringPixelRow++
)
{
for (
int neighboringPixelCol = col - radiusEffectiveRange;
neighboringPixelCol <= col + radiusEffectiveRange;
neighboringPixelCol++
)
{
// This is used so we don't try to get a pixel that's outside the boundaries
// of the image (e.g. (-1, 0))
int chosenRow = Math.Min(_sourceImage.Height - 1, Math.Max(0, neighboringPixelRow));
int chosenCol = Math.Min(_sourceImage.Width - 1, Math.Max(0, neighboringPixelCol));
// The Gaussian Formula is: (e ^ ((x^2 + y^2) / 2 * radius^2)) / (2 * PI * radius^2)
// Here, x = col and y = row. We have to subtract the neighboringPixelCol/Row from
// col/row so that we can translate the coordinate back to the origin. This is because
// the gaussian function is expressed as a function from the distance from the origin
double exponentNumerator = ((neighboringPixelCol - col) * (neighboringPixelCol - col)) +
((neighboringPixelRow - row) * (neighboringPixelRow - row));
double gaussianWeight = Math.Exp(-exponentNumerator / exponentDenominator)
/ gaussianWeightDenominator;
Color currentPixel = _sourceImage.GetPixel(chosenCol, chosenRow);
neighborhoodRedPixelWeightedSum += currentPixel.R * gaussianWeight;
neighborhoodGreenPixelWeightedSum += currentPixel.G * gaussianWeight;
neighborhoodBluePixelWeightedSum += currentPixel.B * gaussianWeight;
sumOfGaussianValues += gaussianWeight;
}
}
outputBitmap.SetPixel(col, row, Color.FromArgb(
(int)Math.Round(neighborhoodRedPixelWeightedSum / sumOfGaussianValues),
(int)Math.Round(neighborhoodGreenPixelWeightedSum / sumOfGaussianValues),
(int)Math.Round(neighborhoodBluePixelWeightedSum / sumOfGaussianValues)
));
}
}
outputBitmap.Lock();
return outputBitmap.GetImage().ToMaybe<Image>();
}
}
catch (Exception)
{
}
return Maybe<Image>.Nothing;
}