public void neighborhoodOperationHSV(int[] mask, DirectBitmap directBitmapPre, DirectBitmap directBitmapPost, KernelMethod _method = KernelMethod.NoBorders, SccalingMethod sccalingMethod = SccalingMethod.Cut, Boolean directionEdge = false)
{
int maskSize = (int)Math.Sqrt(mask.Length);
int calculatedPixel = 0;
HSVBit calculatedHSVBit = new HSVBit();
int maskSum = mask.Min() < 0 ? 1 : mask.Sum();
int maskSumInner = 0;
List <float> angles = new List <float>();
int[] bitMapToScale = null;
int minPixel = directBitmapPre.getMin();
int maxPixel = directBitmapPre.getMax();
int maskValue;
int xo;
int yo;
int lowerXOverlap = 0;
int higherXOverlap = 0;
int lowerYOverlap = 0;
int higherYOverlap = 0;
int yiInner = 0;
int calculatedPixelIndexX = 0;
int calculatedPixelIndexY = 0;
Color helpColor;
HSVBit helperhSVBit;
int overlap = 0; // = maskSize / 2;
int maskOverlap = maskSize / 2;
switch (_method)
{
case KernelMethod.NoBorders:
overlap = maskSize / 2;
break;
case KernelMethod.CloneBorder:
overlap = 0;
break;
case KernelMethod.UseExisting:
overlap = 0;
break;
}
//Iterate through image
for (int x = overlap; x < directBitmapPre.Width - overlap; ++x)
{
for (int y = overlap; y < directBitmapPre.Height - overlap; ++y)
{
//Iterate through image
//Iterate through mask
for (int xi = 0; xi < maskSize; xi++)
{
for (int yi = 0; yi < maskSize; yi++)
{
maskValue = mask[xi + (yi * maskSize)];
xo = x + xi - maskOverlap;
yo = y + yi - maskOverlap;
calculatedPixelIndexX = x + xi - maskOverlap;
calculatedPixelIndexY = y + yi - maskOverlap;
if ((x == 0 && y == 0) || (x == directBitmapPre.Width && y == directBitmapPre.Height))
{
higherXOverlap = 0;
}
if (_method == KernelMethod.UseExisting && (calculatedPixelIndexX < 0 || calculatedPixelIndexY < 0 || calculatedPixelIndexX >= directBitmapPre.Width || calculatedPixelIndexY >= directBitmapPre.Height))
{
continue;
}
if (_method == KernelMethod.CloneBorder && (calculatedPixelIndexX < 0 || calculatedPixelIndexY < 0 || calculatedPixelIndexX >= directBitmapPre.Width || calculatedPixelIndexY >= directBitmapPre.Height))
{
var cloneIndexValue = mask[xi + (yi * maskSize)];
for (int i = 0; i < cloneIndexValue; i++)
{
angles.Add(directBitmapPre.GetPixelHSV(x, y).HUE);
}
calculatedHSVBit.value += (directBitmapPre.GetPixelHSV(xi, yi).saturation *cloneIndexValue);
continue;
}
var cloneIndexValueMain = mask[xi + (yi * maskSize)];
maskSumInner += cloneIndexValueMain;
for (int i = 0; i < cloneIndexValueMain; i++)
{
angles.Add(directBitmapPre.GetPixelHSV(calculatedPixelIndexX, calculatedPixelIndexY).HUE);
}
//calculatedHSVBit.HUE += (directBitmapPre.GetPixelHSV(x, y).HUE * cloneIndexValueMain);
calculatedHSVBit.saturation += (directBitmapPre.GetPixelHSV(calculatedPixelIndexX, calculatedPixelIndexY).saturation *cloneIndexValueMain);
calculatedHSVBit.value += (directBitmapPre.GetPixelHSV(calculatedPixelIndexX, calculatedPixelIndexY).value *cloneIndexValueMain);
}
}
if (_method == KernelMethod.UseExisting)
{
calculatedHSVBit.HUE = this.MeanAngle(angles.ToArray());
calculatedHSVBit.saturation = maskSum == 1 ? calculatedHSVBit.saturation : calculatedHSVBit.saturation / maskSumInner;
calculatedHSVBit.value = maskSum == 1 ? calculatedHSVBit.value : calculatedHSVBit.value / maskSumInner;
//calculatedPixel = maskSum == 1 ? calculatedPixel : calculatedPixel / maskSumInner;
}
else
{
var bit = directBitmapPost.GetPixelHSV(x, y);
// calculatedPixel /= maskSum;
calculatedHSVBit.HUE = this.MeanAngle(angles.ToArray());
calculatedHSVBit.saturation = maskSum == 1 ? calculatedHSVBit.saturation : calculatedHSVBit.saturation / maskSumInner;
calculatedHSVBit.value = maskSum == 1 ? calculatedHSVBit.value : calculatedHSVBit.value / maskSumInner;
}
int newPixel = calculatedPixel;
if (sccalingMethod != SccalingMethod.Scale)
{
newPixel = this.ScalePixelValue(newPixel, sccalingMethod, sccalingMethod == SccalingMethod.Scale ? minPixel : 0, sccalingMethod == SccalingMethod.Scale ? maxPixel : 255);
}
if (sccalingMethod != SccalingMethod.Scale)
{
var bit = directBitmapPost.GetPixelHSV(x, y);
calculatedHSVBit.saturation = bit.saturation;
calculatedHSVBit.HUE = bit.HUE;
//apply cut scalling
if (calculatedHSVBit.value > 1)
{
calculatedHSVBit.value = 1;
}
if (calculatedHSVBit.value < 0)
{
calculatedHSVBit.value = 0;
}
directBitmapPost.SetPixel(x, y, calculatedHSVBit.getColor());
}
else
{
bitMapToScale[x + (y * directBitmapPre.Width)] = newPixel;
}
maskSumInner = 0;
calculatedPixel = 0;
calculatedHSVBit.HUE = 0;
calculatedHSVBit.saturation = 0;
calculatedHSVBit.value = 0;
angles.Clear();
}
}
}
public int[] sobelPrewwitOperation(KernelMethod kernelMethod = KernelMethod.NoBorders, SccalingMethod sccalingMethod = SccalingMethod.Cut, DirectionEdgeMask directionEdgeMask = DirectionEdgeMask.Prewwit)
{
//TODO: Merge all neighborhood operations in little framework, big code redundancy, but its prototype so cool
int[] bitmapPreScaleFirst = new int[directBitmapPre.Width * directBitmapPre.Height];
int[] bitmapPreScaleSecond = new int[directBitmapPre.Width * directBitmapPre.Height];
int[] resultImage = new int[directBitmapPre.Width * directBitmapPre.Height];
int xBond = kernelMethod == KernelMethod.NoBorders ? 1 : 0;
List <int> maskSumFirst;
List <int> maskSumSecond;
int calculatedX;
int calculatedY;
int[] maskFirst = null;
int[] maskSecond = null;
switch (directionEdgeMask)
{
case DirectionEdgeMask.Prewwit:
maskFirst = ImageProcessingEngine.PrewwitFirst;
maskSecond = ImageProcessingEngine.PrewwitSecond;
break;
case DirectionEdgeMask.Sobel:
maskFirst = ImageProcessingEngine.SobelFirst;
maskSecond = ImageProcessingEngine.SobelSecond;
break;
}
const int maskSize = 3;
int overlap = 0; // = maskSize / 2;
int maskOverlap = maskSize / 2;
switch (kernelMethod)
{
case KernelMethod.NoBorders:
overlap = maskSize / 2;
break;
case KernelMethod.CloneBorder:
overlap = 0;
break;
case KernelMethod.UseExisting:
overlap = 0;
break;
}
for (int x = overlap; x < directBitmapPre.Width - overlap; ++x)
{
for (int y = overlap; y < directBitmapPre.Height - overlap; ++y)
{
maskSumFirst = new List <int>();
maskSumSecond = new List <int>();
for (int xi = 0; xi < 3; xi++)
{
for (int yi = 0; yi < 3; yi++)
{
calculatedX = x + xi - maskOverlap;
calculatedY = y + yi - maskOverlap;
if (kernelMethod == KernelMethod.UseExisting)
{
if (calculatedX >= directBitmapPre.Width || calculatedY >= directBitmapPre.Height || calculatedX < 0 || calculatedY < 0)
{
continue;
}
}
else if (kernelMethod == KernelMethod.CloneBorder)
{
if (calculatedX >= directBitmapPre.Width || calculatedY >= directBitmapPre.Height || calculatedX < 0 || calculatedY < 0)
{
//mask[xi + (yi * maskSize)]
maskSumFirst.Add(maskFirst[xi + (yi * 3)] * directBitmapPre.GetPixel(x, y).R);
maskSumSecond.Add(maskSecond[xi + (yi * 3)] * directBitmapPre.GetPixel(x, y).R);
continue;
}
}
maskSumFirst.Add(maskFirst[xi + (yi * 3)] * directBitmapPre.GetPixel(calculatedX, calculatedY).R);
maskSumSecond.Add(maskSecond[xi + (yi * 3)] * directBitmapPre.GetPixel(calculatedX, calculatedY).R);
}
}
bitmapPreScaleFirst[x + (y * directBitmapPre.Width)] = Math.Abs(maskSumFirst.Sum());
bitmapPreScaleSecond[x + (y * directBitmapPre.Width)] = Math.Abs(maskSumSecond.Sum());
}
}
int finalPixel = 0;
for (int x = 0; x < directBitmapPre.Width; x++)
{
for (int y = 0; y < directBitmapPre.Height; y++)
{
finalPixel = bitmapPreScaleFirst[x + (y * directBitmapPre.Width)] + bitmapPreScaleSecond[x + (y * directBitmapPre.Width)];
resultImage[x + (y * directBitmapPre.Width)] = finalPixel;
}
}
int min = resultImage.Min();
int max = resultImage.Max();
// resultImage.Select(x => this.ScalePixelValue( x, sccalingMethod, min, max));
for (int i = 0; i < directBitmapPre.Height * directBitmapPost.Width; i++)
{
resultImage[i] = this.ScalePixelValue(resultImage[i], sccalingMethod, min, max);
}
directBitmapPost.load(resultImage);
return(resultImage);
}
public int[] robertsOperation(KernelMethod kernelMethod = KernelMethod.NoBorders, SccalingMethod sccalingMethod = SccalingMethod.Cut)
{
int[] bitmapPreScaleFirst = new int[directBitmapPre.Width * directBitmapPre.Height];
int[] bitmapPreScaleSecond = new int[directBitmapPre.Width * directBitmapPre.Height];
int[] resultImage = new int[directBitmapPre.Width * directBitmapPre.Height];
int xBond = kernelMethod == KernelMethod.NoBorders ? 1 : 0;
List <int> maskSumFirst;
List <int> maskSumSecond;
int calculatedX;
int calculatedY;
int[] maskFirst = ImageProcessingEngine.RobertsFirst;
int[] maskSecond = ImageProcessingEngine.RobertsSecond;
for (int x = 0; x < directBitmapPre.Width - xBond; ++x)
{
for (int y = 0; y < directBitmapPre.Height - xBond; ++y)
{
maskSumFirst = new List <int>();
maskSumSecond = new List <int>();
for (int xi = 0; xi < 2; xi++)
{
for (int yi = 0; yi < 2; yi++)
{
calculatedX = x + xi;
calculatedY = y + yi;
if (kernelMethod == KernelMethod.UseExisting)
{
if (calculatedX >= directBitmapPre.Width || calculatedY >= directBitmapPre.Height)
{
continue;
}
}
else if (kernelMethod == KernelMethod.CloneBorder)
{
if (calculatedX >= directBitmapPre.Width || calculatedY >= directBitmapPre.Height)
{
//mask[xi + (yi * maskSize)]
maskSumFirst.Add(maskFirst[xi + (yi * 2)] * directBitmapPre.GetPixel(x, y).R);
maskSumSecond.Add(maskSecond[xi + (yi * 2)] * directBitmapPre.GetPixel(x, y).R);
continue;
}
}
maskSumFirst.Add(maskFirst[xi + (yi * 2)] * directBitmapPre.GetPixel(x + xi, y + yi).R);
maskSumSecond.Add(maskSecond[xi + (yi * 2)] * directBitmapPre.GetPixel(x + xi, y + yi).R);
}
}
bitmapPreScaleFirst[x + (y * directBitmapPre.Width)] = Math.Abs(maskSumFirst.Sum());
bitmapPreScaleSecond[x + (y * directBitmapPre.Width)] = Math.Abs(maskSumSecond.Sum());
}
}
int finalPixel = 0;
for (int x = 0; x < directBitmapPre.Width; x++)
{
for (int y = 0; y < directBitmapPre.Height; y++)
{
finalPixel = bitmapPreScaleFirst[x + (y * directBitmapPre.Width)] + bitmapPreScaleSecond[x + (y * directBitmapPre.Width)];
resultImage[x + (y * directBitmapPre.Width)] = finalPixel;
}
}
int min = resultImage.Min();
int max = resultImage.Max();
// resultImage.Select(x => this.ScalePixelValue( x, sccalingMethod, min, max));
for (int i = 0; i < directBitmapPre.Height * directBitmapPost.Width; i++)
{
resultImage[i] = this.ScalePixelValue(resultImage[i], sccalingMethod, min, max);
}
directBitmapPost.load(resultImage);
return(resultImage);
}
public void directEdgeOperation(DirectionEdgeMask directionEdgeMask, SccalingMethod sccalingMethod = SccalingMethod.Cut, KernelMethod kernelMethod = KernelMethod.NoBorders)
{
DirectBitmap directBitMapFinal = null;
//Bitmaps for performing operations
int[] bitmapPreScaleFirst = new int[directBitmapPre.Width * directBitmapPre.Height];
int[] bitmapPreScaleSecond = new int[directBitmapPre.Width * directBitmapPre.Height];
int[] maskFirst;
int[] maskSecond;
switch (directionEdgeMask)
{
case DirectionEdgeMask.Roberts:
maskFirst = ImageProcessingEngine.RobertsFirst;
maskSecond = ImageProcessingEngine.RobertsSecond;
break;
case DirectionEdgeMask.Sobel:
maskFirst = ImageProcessingEngine.SobelFirst;
maskSecond = ImageProcessingEngine.SobelSecond;
break;
case DirectionEdgeMask.Prewwit:
maskFirst = ImageProcessingEngine.PrewwitFirst;
maskSecond = ImageProcessingEngine.PrewwitSecond;
break;
}
}
public void medianOperation(int maskSize, KernelMethod _method = KernelMethod.NoBorders)
{
List <int> maskList = null;
int[] maskObject = new int[maskSize * maskSize]; ///for easier median search using list
//Array.Sort(maskObject);
int calculatedPixel;
int elementttt;
int overlap = 0;
int maskSizeInner = 0; //mask size used for UseExisting method
switch (_method)
{
case KernelMethod.NoBorders:
overlap = maskSize / 2;
break;
case KernelMethod.CloneBorder:
overlap = 0;
break;
case KernelMethod.UseExisting:
overlap = 0;
break;
}
Color helpColor;
int maskOverlap = maskSize / 2;
int calculatedPixelXIndex = 0;
int calculatedPixelYindex = 0;
//Iterate through image
for (int x = overlap; x < directBitmapPre.Width - overlap; ++x)
{
for (int y = overlap; y < directBitmapPre.Height - overlap; ++y)
{
//Iterate through image
//Iterate through mask
maskList = new List <int>();
for (int xi = 0; xi < maskSize; xi++)
{
for (int yi = 0; yi < maskSize; yi++)
{
calculatedPixelXIndex = x + xi - maskOverlap;
calculatedPixelYindex = y + yi - maskOverlap;
if (_method == KernelMethod.UseExisting)
{
if ((calculatedPixelXIndex < 0 || calculatedPixelYindex < 0 || calculatedPixelXIndex >= directBitmapPre.Width || calculatedPixelYindex >= directBitmapPre.Height))
{
continue;
}
else
{
maskSizeInner++;
}
}
if (_method == KernelMethod.CloneBorder && (calculatedPixelXIndex < 0 || calculatedPixelYindex < 0 || calculatedPixelXIndex >= directBitmapPre.Width || calculatedPixelYindex >= directBitmapPre.Height))
{
calculatedPixelXIndex = x;
calculatedPixelYindex = y;
}
maskList.Add(directBitmapPre.GetPixel(calculatedPixelXIndex, calculatedPixelYindex).R);
}
}
calculatedPixel = maskList.Median();
directBitmapPost.SetPixel(x, y, Color.FromArgb(calculatedPixel, calculatedPixel, calculatedPixel));
}
}
}
public void neighborhoodOperation(int[] mask, KernelMethod _method = KernelMethod.NoBorders, SccalingMethod sccalingMethod = SccalingMethod.Cut, Boolean directionEdge = false)
{
int maskSize = (int)Math.Sqrt(mask.Length);
int calculatedPixel = 0;
int maskSum = mask.Min() < 0 ? 1 : mask.Sum();
int maskSumInner = 0;
int[] bitMapToScale = null;
if (sccalingMethod == SccalingMethod.Scale)
{
bitMapToScale = new int[directBitmapPre.Height * directBitmapPre.Width];
}
int minPixel = directBitmapPre.getMin();
int maxPixel = directBitmapPre.getMax();
int maskValue;
int xo;
int yo;
int lowerXOverlap = 0;
int higherXOverlap = 0;
int lowerYOverlap = 0;
int higherYOverlap = 0;
int yiInner = 0;
int calculatedPixelIndexX = 0;
int calculatedPixelIndexY = 0;
Color helpColor;
int overlap = 0; // = maskSize / 2;
int maskOverlap = maskSize / 2;
switch (_method)
{
case KernelMethod.NoBorders:
overlap = maskSize / 2;
break;
case KernelMethod.CloneBorder:
overlap = 0;
break;
case KernelMethod.UseExisting:
overlap = 0;
break;
}
//Iterate through image
for (int x = overlap; x < directBitmapPre.Width - overlap; ++x)
{
for (int y = overlap; y < directBitmapPre.Height - overlap; ++y)
{
//Iterate through image
//Iterate through mask
for (int xi = 0; xi < maskSize; xi++)
{
for (int yi = 0; yi < maskSize; yi++)
{
maskValue = mask[xi + (yi * maskSize)];
xo = x + xi - maskOverlap;
yo = y + yi - maskOverlap;
calculatedPixelIndexX = x + xi - maskOverlap;
calculatedPixelIndexY = y + yi - maskOverlap;
if ((x == 0 && y == 0) || (x == directBitmapPre.Width && y == directBitmapPre.Height))
{
higherXOverlap = 0;
}
if (_method == KernelMethod.UseExisting && (calculatedPixelIndexX < 0 || calculatedPixelIndexY < 0 || calculatedPixelIndexX >= directBitmapPre.Width || calculatedPixelIndexY >= directBitmapPre.Height))
{
continue;
}
if (_method == KernelMethod.CloneBorder && (calculatedPixelIndexX < 0 || calculatedPixelIndexY < 0 || calculatedPixelIndexX >= directBitmapPre.Width || calculatedPixelIndexY >= directBitmapPre.Height))
{
calculatedPixel += (directBitmapPre.GetPixel(x, y).R *mask[xi + (yi * maskSize)]);
continue;
}
maskSumInner += mask[xi + (yi * maskSize)];
calculatedPixel += (directBitmapPre.GetPixel(calculatedPixelIndexX, calculatedPixelIndexY).R *mask[xi + (yi * maskSize)]);
}
}
if (_method == KernelMethod.UseExisting)
{
calculatedPixel = maskSum == 1 ? calculatedPixel : calculatedPixel / maskSumInner;
}
else
{
calculatedPixel /= maskSum;
}
int newPixel = calculatedPixel;
if (sccalingMethod != SccalingMethod.Scale)
{
newPixel = this.ScalePixelValue(newPixel, sccalingMethod, sccalingMethod == SccalingMethod.Scale ? minPixel : 0, sccalingMethod == SccalingMethod.Scale ? maxPixel : 255);
}
if (sccalingMethod != SccalingMethod.Scale)
{
directBitmapPost.SetPixel(x, y, Color.FromArgb(newPixel, newPixel, newPixel));
}
else
{
bitMapToScale[x + (y * directBitmapPre.Width)] = newPixel;
}
maskSumInner = 0;
calculatedPixel = 0;
}
}
if (sccalingMethod == SccalingMethod.Scale)
{
int minValue = bitMapToScale.Min();
int maxValue = bitMapToScale.Max();
int pixelScalled;
List <int> checkList = new List <int>();
for (int x = 0; x < directBitmapPre.Width - overlap; ++x)
{
for (int y = 0; y < directBitmapPre.Height - overlap; ++y)
{
pixelScalled = (int)(((decimal)(bitMapToScale[x + (y * directBitmapPre.Width)] - minValue) / (decimal)(maxValue - minValue)) * 255);
checkList.Add(pixelScalled);
directBitmapPost.SetPixel(x, y, Color.FromArgb(pixelScalled, pixelScalled, pixelScalled));
}
}
}
}
