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