//========================================================
//for double image
/// <summary>
/// Get the height of the image
/// </summary>
/// <param name="ImageMatrix">2D array that contains the image</param>
/// <returns>Image Height</returns>
public static int GetHeightDouble(MyColorDouble[,] ImageMatrix)
{
return ImageMatrix.GetLength(0);
}
/// <summary>
/// Gamma - Contrast Image
/// </summary>
public static MyColor[,] GammaContrastImage(MyColorDouble[,] GImageMatrix)
{
MyColorDouble Old_Min, Old_Max;
Old_Min.red = 0; Old_Min.green = 0; Old_Min.blue = 0;
Old_Max.red = 0; Old_Max.green = 0; Old_Max.blue = 0;
double NewPixelRed, NewPixelBlue, NewPixelGreen;
MyColor X = new MyColor();
MyColor[,] NewImageMatrix = new MyColor[GetHeightDouble(GImageMatrix), GetWidthDouble(GImageMatrix)];
Gamma_GetMinMax(GImageMatrix, ref Old_Min.red, ref Old_Max.red, ref Old_Min.blue, ref Old_Max.blue, ref Old_Min.green, ref Old_Max.green);
for (int i = 0; i < GetHeightDouble(GImageMatrix); i++)
{
for (int j = 0; j < GetWidthDouble(GImageMatrix); j++)
{
NewPixelRed = ((GImageMatrix[i, j].red - Old_Min.red) / (Old_Max.red - Old_Min.red)) * (255 - 0) + 0;
NewPixelBlue = ((GImageMatrix[i, j].blue - Old_Min.blue) / (Old_Max.blue - Old_Min.blue)) * (255 - 0) + 0;
NewPixelGreen = ((GImageMatrix[i, j].green - Old_Min.green) / (Old_Max.green - Old_Min.green)) * (255 - 0) + 0;
if (NewPixelRed > 255)
NewPixelRed = 255;
if (NewPixelRed < 0)
NewPixelRed = 0;
if (NewPixelBlue > 255)
NewPixelBlue = 255;
if (NewPixelBlue < 0)
NewPixelBlue = 0;
if (NewPixelGreen > 255)
NewPixelGreen = 255;
if (NewPixelGreen < 0)
NewPixelGreen = 0;
X.red = (byte)(NewPixelRed);
X.blue = (byte)(NewPixelBlue);
X.green = (byte)(NewPixelGreen);
NewImageMatrix[i, j] = X;
}
}
return NewImageMatrix;
}
/// <summary>
/// Gamma - Get Minimum and Maximum
/// </summary>
public static void Gamma_GetMinMax(MyColorDouble[,] GImageMatrix, ref double redmin, ref double redmax, ref double bluemin, ref double bluemax, ref double greenmin, ref double greenmax)
{
redmin = 100000;
redmax = 0;
bluemin = 100000;
bluemax = 0;
greenmin = 100000;
greenmax = 0;
int Height = GetHeightDouble(GImageMatrix);
int Width = GetWidthDouble(GImageMatrix);
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
if (GImageMatrix[i, j].red < redmin)
redmin = GImageMatrix[i, j].red;
if (GImageMatrix[i, j].blue < bluemin)
bluemin = GImageMatrix[i, j].blue;
if (GImageMatrix[i, j].green < greenmin)
greenmin = GImageMatrix[i, j].green;
}
}
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
if (GImageMatrix[i, j].red > redmax)
redmax = GImageMatrix[i, j].red;
if (GImageMatrix[i, j].blue > bluemax)
bluemax = GImageMatrix[i, j].blue;
if (GImageMatrix[i, j].green > greenmax)
greenmax = GImageMatrix[i, j].green;
}
}
}
/// <summary>
/// Contrast Image - Normal/Efficient Min-Max Algorithm
/// </summary>
/// <param name="ImageMatrix">2D ImageMatrix that contains the image</param>
/// <param name="New">Contrast degree</param>
/// <returns>2D ImageMatrix of contrasted image colors</returns>
public static MyColor[,] ContrastImage_Normal(MyColor[,] ImageMatrix, double New)
{
// Start a new StopWatch object for calculating the time
// The variable stopWatch is a GLOBAL variable.
stopWatch = Stopwatch.StartNew();
MyColorDouble OldMin = new MyColorDouble();
MyColorDouble OldMax = new MyColorDouble();
MyColorDouble NewMin = new MyColorDouble();
MyColorDouble NewMax = new MyColorDouble();
MyColorDouble NewPixel = new MyColorDouble();
MyColor X = new MyColor();
MyColor[,] NewImageMatrix = new MyColor[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
/* To calculate Minimum and Maximum Pixel in the image */
/* Normal Algorithm */
GetMinMax_Normal(ImageMatrix, ref OldMin.red, ref OldMax.red, ref OldMin.blue, ref OldMax.blue, ref OldMin.green, ref OldMax.green);
NewMin.red = OldMin.red - New;
NewMax.red = OldMax.red + New;
NewMin.blue = OldMin.red - New;
NewMax.blue = OldMax.red + New;
NewMin.green = OldMin.red - New;
NewMax.green = OldMax.red + New;
for (int i = 0; i < GetHeight(ImageMatrix); i++)
{
for (int j = 0; j < GetWidth(ImageMatrix); j++)
{
NewPixel.red = ((ImageMatrix[i, j].red - OldMin.red) / (OldMax.red - OldMin.red)) * (NewMax.red - NewMin.red) + NewMin.red;
NewPixel.blue = ((ImageMatrix[i, j].blue - OldMin.blue) / (OldMax.red - OldMin.blue)) * (NewMax.blue - NewMin.blue) + NewMin.blue;
NewPixel.green = ((ImageMatrix[i, j].green - OldMin.green) / (OldMax.green - OldMin.green)) * (NewMax.green - NewMin.green) + NewMin.green;
if (NewPixel.red > 255)
NewPixel.red = 255;
if (NewPixel.red < 0)
NewPixel.red = 0;
if (NewPixel.blue > 255)
NewPixel.blue = 255;
if (NewPixel.blue < 0)
NewPixel.blue = 0;
if (NewPixel.green > 255)
NewPixel.green = 255;
if (NewPixel.green < 0)
NewPixel.green = 0;
X.red = (byte)(NewPixel.red);
X.blue = (byte)(NewPixel.blue);
X.green = (byte)(NewPixel.green);
NewImageMatrix[i, j] = X;
}
}
// Calculating the time
stopWatch.Stop();
elapsedMs = stopWatch.ElapsedMilliseconds;
// Return the new contrasted image
return NewImageMatrix;
}
/// <summary>
/// Blur Image - Efficient Algorithm
/// </summary>
/// <param name="ImageMatrix">2D ImageMatrix that contains the image</param>
/// <param name="BlurMaskSize">Blur Degree</param>
/// <returns>2D ImageMatrix of contrasted image colors</returns>
public static MyColor[,] BlurImage_Efficient(MyColor[,] ImageMatrix, int BlurMaskSize)
{
// Start a new StopWatch object for calculating the time
// The variable stopWatch is a GLOBAL variable.
stopWatch = Stopwatch.StartNew();
// MAP stores blurr degree and index of center of mask
Dictionary<int, int> MaskCenterElement = new Dictionary<int, int>();
MaskCenterElement.Add(3, 1);
MaskCenterElement.Add(5, 2);
MaskCenterElement.Add(7, 3);
MaskCenterElement.Add(9, 4);
MaskCenterElement.Add(11, 5);
MaskCenterElement.Add(13, 6);
MaskCenterElement.Add(15, 7);
MaskCenterElement.Add(17, 8);
double MaskElementValue = 1.0 / (BlurMaskSize * BlurMaskSize);
double Value = 1.0 / BlurMaskSize;
// Center Index of needed blurr degree
int MaskCenterIndex = 0;
foreach (var index in MaskCenterElement)
{
if (index.Key == BlurMaskSize)
{
MaskCenterIndex = index.Value;
break;
}
}
// Original image matrix (size: Height+(CenterIndex * 2) x Width+(CenterIndex * 2))
MyColor[,] OriginalImage = new MyColor[GetHeight(ImageMatrix) + (MaskCenterIndex * 2), GetWidth(ImageMatrix) + (MaskCenterIndex * 2)];
for (int x = MaskCenterIndex; x < GetHeight(ImageMatrix) + MaskCenterIndex; x++)
{
for (int y = MaskCenterIndex; y < GetWidth(ImageMatrix) + MaskCenterIndex; y++)
OriginalImage[x, y] = ImageMatrix[x - MaskCenterIndex, y - MaskCenterIndex];
}
// The new blurred image matrix
MyColor[,] NewImageMatrix = new MyColor[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
MyColor[,] tempMatrix = new MyColor[GetHeight(OriginalImage), GetWidth(OriginalImage)];
MyColorDouble SumOfMaskTimesOldPixel = new MyColorDouble();
SumOfMaskTimesOldPixel.red = 0; SumOfMaskTimesOldPixel.green = 0;
SumOfMaskTimesOldPixel.blue = 0;
//Move Horizontally
//"mRows" moves all the rows in the picture
//"nCols" ONLY is constrained to the #of columns - BlurMaskSize
for (int mRows = 0; mRows < GetHeight(OriginalImage); mRows++)
{
for (int nCols = 0; nCols < GetWidth(OriginalImage) - BlurMaskSize; nCols++)
{
SumOfMaskTimesOldPixel.red = 0;
SumOfMaskTimesOldPixel.green = 0;
SumOfMaskTimesOldPixel.blue = 0;
for (int k = 0; k < BlurMaskSize; k++)
{
SumOfMaskTimesOldPixel.red += (Value * OriginalImage[mRows, nCols + k].red);
SumOfMaskTimesOldPixel.green += (Value * OriginalImage[mRows, nCols + k].green);
SumOfMaskTimesOldPixel.blue += (Value * OriginalImage[mRows, nCols + k].blue);
}
tempMatrix[mRows, nCols + MaskCenterIndex].red = (byte)SumOfMaskTimesOldPixel.red;
tempMatrix[mRows, nCols + MaskCenterIndex].green = (byte)SumOfMaskTimesOldPixel.green;
tempMatrix[mRows, nCols + MaskCenterIndex].blue = (byte)SumOfMaskTimesOldPixel.blue;
}
}
//Move Vertically
/*"nCols" moves all the columns in the picture minus CenterIndex
*"mRows" ONLY is constrained to the #of rows - BlurMaskSize
*"nCols" starts at the CenterIndex column b/z NewImageMatrix starts from the 2nd column in tempMatrix and not the first.
*For the same reason it ends at the last column "-1", because NewImageMatrix doesn't have the last column in the tempMatrix.
*/
for (int mRows = 0; mRows < GetHeight(tempMatrix) - BlurMaskSize; mRows++)
{
for (int nCols = MaskCenterIndex; nCols < GetWidth(tempMatrix)-MaskCenterIndex; nCols++)
{
SumOfMaskTimesOldPixel.red = 0;
SumOfMaskTimesOldPixel.green = 0;
SumOfMaskTimesOldPixel.blue = 0;
for (int k = 0; k < BlurMaskSize; k++)
{
SumOfMaskTimesOldPixel.red += (Value * tempMatrix[mRows + k, nCols].red);
SumOfMaskTimesOldPixel.green += (Value * tempMatrix[mRows + k, nCols].green);
SumOfMaskTimesOldPixel.blue += (Value * tempMatrix[mRows + k, nCols].blue);
}
NewImageMatrix[mRows, nCols - MaskCenterIndex].red = (byte)SumOfMaskTimesOldPixel.red;
NewImageMatrix[mRows, nCols - MaskCenterIndex].green = (byte)SumOfMaskTimesOldPixel.green;
NewImageMatrix[mRows, nCols - MaskCenterIndex].blue = (byte)SumOfMaskTimesOldPixel.blue;
}
}
// Calculating the time
stopWatch.Stop();
elapsedMs = stopWatch.ElapsedMilliseconds;
// Return the new blurred image
return NewImageMatrix;
}
/// <summary>
/// Calculate Gamma Correction - Normal
/// </summary>
public static MyColor[,] CalculateGammaCorrection_Normal(MyColor[,] ImageMatrix, MyColor[,] NonImageMatrix)
{
// Start a new StopWatch object for calculating the time
// The variable stopWatch is a GLOBAL variable.
stopWatch = Stopwatch.StartNew();
MyColorDouble Y = new MyColorDouble();
MyColorDouble[,] GammaCImage = new MyColorDouble[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
MyColor[,] ModGammaCImage = new MyColor[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
var errors = new Dictionary<double, double>();
MyColor X = new MyColor();
MyColor[,] GammaCorrImage = new MyColor[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
MyColorDouble New, diff;
double error, sum, minerror = 10000000, difference;
double Height = GetHeight(ImageMatrix);
double Width = GetWidth(ImageMatrix);
for (double x = 0.1; x < 5; x += 0.1)
{
sum = 0;
difference = 0;
diff.red = 0;
diff.blue = 0;
diff.green = 0;
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
New.red = Math.Pow(NonImageMatrix[i, j].red, x);
New.blue = Math.Pow(NonImageMatrix[i, j].blue, x);
New.green = Math.Pow(NonImageMatrix[i, j].green, x);
Y.red = New.red;
Y.blue = New.blue;
Y.green = New.green;
GammaCImage[i, j] = Y;
}
}
ModGammaCImage = GammaContrastImage(GammaCImage);
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
diff.red = ImageMatrix[i, j].red - ModGammaCImage[i, j].red;
diff.blue = ImageMatrix[i, j].blue - ModGammaCImage[i, j].blue;
diff.green = ImageMatrix[i, j].green - ModGammaCImage[i, j].green;
difference = Math.Abs(diff.red) + Math.Abs(diff.blue) + Math.Abs(diff.green);
sum += Math.Pow(difference, 2);
}
}
error = (1 / (Height * Width)) * sum;
errors[x] = error;
}
foreach (var index in errors)
{
if (minerror >= index.Value)
{
minerror = index.Value;
gammavalueNormal = index.Key;
}
}
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
New.red = Math.Pow(NonImageMatrix[i, j].red, gammavalueNormal);
New.blue = Math.Pow(NonImageMatrix[i, j].blue, gammavalueNormal);
New.green = Math.Pow(NonImageMatrix[i, j].green, gammavalueNormal);
Y.red = New.red;
Y.blue = New.blue;
Y.green = New.green;
GammaCImage[i, j] = Y;
}
}
ModGammaCImage = GammaContrastImage(GammaCImage);
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
X.red = (byte)(ModGammaCImage[i, j].red);
X.blue = (byte)(ModGammaCImage[i, j].blue);
X.green = (byte)(ModGammaCImage[i, j].green);
GammaCorrImage[i, j] = X;
}
}
// Calculating the time
stopWatch.Stop();
elapsedMs = stopWatch.ElapsedMilliseconds;
return GammaCorrImage;
}
/// <summary>
/// Calculate Gamma Correction - Efficient
/// </summary>
public static MyColor[,] CalculateGammaCorrection_Efficient(MyColor[,] ImageMatrix, MyColor[,] NonImageMatrix)
{
// Start a new StopWatch object for calculating the time
// The variable stopWatch is a GLOBAL variable.
stopWatch = Stopwatch.StartNew();
MyColorDouble New ;
MyColor X = new MyColor();
MyColor[,] GammaCorrImage = new MyColor[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
MyColor[,] ModGammaCImage = new MyColor[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
MyColorDouble Y = new MyColorDouble();
MyColorDouble[,] GammaCImage = new MyColorDouble[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
double Height = GetHeight(ImageMatrix);
double Width = GetWidth(ImageMatrix);
gammavalueEfficient = UNIMODALSEARCH(ImageMatrix, NonImageMatrix, 0.1, 5);
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
New.red = Math.Pow(NonImageMatrix[i, j].red, gammavalueEfficient);
New.blue = Math.Pow(NonImageMatrix[i, j].blue, gammavalueEfficient);
New.green = Math.Pow(NonImageMatrix[i, j].green, gammavalueEfficient);
Y.red = New.red;
Y.blue = New.blue;
Y.green = New.green;
GammaCImage[i, j] = Y;
}
}
ModGammaCImage = GammaContrastImage(GammaCImage);
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
X.red = (byte)(ModGammaCImage[i, j].red);
X.blue = (byte)(ModGammaCImage[i, j].blue);
X.green = (byte)(ModGammaCImage[i, j].green);
GammaCorrImage[i, j] = X;
}
}
// Calculating the time
stopWatch.Stop();
elapsedMs = stopWatch.ElapsedMilliseconds;
return GammaCorrImage;
}
/// <summary>
/// Blur Image - Normal Algorithm
/// </summary>
/// <param name="ImageMatrix">2D ImageMatrix that contains the image</param>
/// <param name="BlurMaskSize">Blur Degree</param>
/// <returns>2D ImageMatrix of contrasted image colors</returns>
public static MyColor[,] BlurImage_Normal(MyColor[,] ImageMatrix, int BlurMaskSize)
{
// Start a new StopWatch object for calculating the time
// The variable stopWatch is a GLOBAL variable.
stopWatch = Stopwatch.StartNew();
// MAP stores blurr degree and index of center of mask
Dictionary<int, int> MaskCenterElement = new Dictionary<int, int>();
MaskCenterElement.Add(3, 1);
MaskCenterElement.Add(5, 2);
MaskCenterElement.Add(7, 3);
MaskCenterElement.Add(9, 4);
MaskCenterElement.Add(11, 5);
MaskCenterElement.Add(13, 6);
MaskCenterElement.Add(15, 7);
MaskCenterElement.Add(17, 8);
// Blur Scalar number
double MaskElementValue = 1.0 / (BlurMaskSize * BlurMaskSize);
// Center Index of needed blurr degree
int MaskCenterIndex = 0;
foreach (var index in MaskCenterElement)
{
if (index.Key == BlurMaskSize)
{
MaskCenterIndex = index.Value;
break;
}
}
// Original image matrix (size: Height+(CenterIndex * 2) x Width+(CenterIndex * 2))
MyColor[,] OriginalImage = new MyColor[GetHeight(ImageMatrix) + (MaskCenterIndex * 2), GetWidth(ImageMatrix) + (MaskCenterIndex * 2)];
for (int x = MaskCenterIndex; x < GetHeight(ImageMatrix) + MaskCenterIndex; x++)
{
for (int y = MaskCenterIndex; y < GetWidth(ImageMatrix) + MaskCenterIndex; y++)
OriginalImage[x, y] = ImageMatrix[x - MaskCenterIndex, y - MaskCenterIndex];
}
// The new blurred image matrix
MyColor[,] NewImageMatrix = new MyColor[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
// Blur Mask Matrix
MyColor[,] BlurMask = new MyColor[BlurMaskSize, BlurMaskSize];
// N rows
for (int m = 0; m < GetHeight(OriginalImage) - BlurMaskSize; m++)
{
// N columns
for (int n = 0; n < GetWidth(OriginalImage) - BlurMaskSize; n++)
{
MyColorDouble BlurMaskPixel = new MyColorDouble();
BlurMaskPixel.red = 0; BlurMaskPixel.green = 0; BlurMaskPixel.blue = 0;
MyColorDouble SumOfMaskTimesOldPixel = new MyColorDouble();
SumOfMaskTimesOldPixel.red = 0;
SumOfMaskTimesOldPixel.green = 0;
SumOfMaskTimesOldPixel.blue = 0;
// Create-Fill Mask Values
for (int i = 0, v = m; v < m + BlurMaskSize; i++, v++) //k rows
{
for (int j = 0, x = n; x < n + BlurMaskSize; j++, x++) //k cols
{
BlurMaskPixel.red = (MaskElementValue * OriginalImage[v, x].red);
BlurMaskPixel.green = (MaskElementValue * OriginalImage[v, x].green);
BlurMaskPixel.blue = (MaskElementValue * OriginalImage[v, x].blue);
SumOfMaskTimesOldPixel.red += BlurMaskPixel.red;
SumOfMaskTimesOldPixel.green += BlurMaskPixel.green;
SumOfMaskTimesOldPixel.blue += BlurMaskPixel.blue;
}
}
NewImageMatrix[m, n].red = (byte)SumOfMaskTimesOldPixel.red;
NewImageMatrix[m, n].green = (byte)SumOfMaskTimesOldPixel.green;
NewImageMatrix[m, n].blue = (byte)SumOfMaskTimesOldPixel.blue;
}
}
// Calculating the time
stopWatch.Stop();
elapsedMs = stopWatch.ElapsedMilliseconds;
// Return the new blurred image
return NewImageMatrix;
}
/// <summary>
/// Unimodel Search
/// </summary>
public static double UNIMODALSEARCH(MyColor[,] ImageMatrix, MyColor[,] NonImageMatrix, double low, double high)
{
double mid = 0;
MyColor[,] ModGammaCImage = new MyColor[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
MyColorDouble Y = new MyColorDouble();
MyColorDouble[,] GammaCImage = new MyColorDouble[GetHeight(ImageMatrix), GetWidth(ImageMatrix)];
MyColorDouble New,diff;
double Height = GetHeight(ImageMatrix);
double Width = GetWidth(ImageMatrix);
double difference , sum , error;
double[] errors = new double[3];
int a = 0;
if (low == high)
{
return low;
}
if ( (high+1) % 2 == 0)
mid = (low + high) / 2;
else
mid = (low + high) / 2 + 1;
for (double k = mid - 1 ; k <= mid + 1; k++)
{
sum = 0;
for (int i = 0; i < GetHeight(ImageMatrix); i++)
{
for (int j = 0; j < GetWidth(ImageMatrix); j++)
{
New.red = Math.Pow(NonImageMatrix[i, j].red, k);
New.blue = Math.Pow(NonImageMatrix[i, j].blue, k);
New.green = Math.Pow(NonImageMatrix[i, j].green, k);
Y.red = New.red;
Y.blue = New.blue;
Y.green = New.green;
GammaCImage[i, j] = Y;
}
}
ModGammaCImage = GammaContrastImage(GammaCImage);
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
diff.red = ImageMatrix[i, j].red - ModGammaCImage[i, j].red;
diff.blue = ImageMatrix[i, j].blue - ModGammaCImage[i, j].blue;
diff.green = ImageMatrix[i, j].green - ModGammaCImage[i, j].green;
difference = Math.Abs(diff.red) + Math.Abs(diff.blue) + Math.Abs(diff.green);
sum += Math.Pow(difference, 2);
}
}
error = (1 / (Height * Width)) * sum;
errors[a] = error;
a++;
}
if (errors[1] < errors[0] && errors[1] < errors[2])
return mid;
if (errors[1] < errors[0])
return UNIMODALSEARCH(ImageMatrix , NonImageMatrix, mid + 1, high);
else
return UNIMODALSEARCH(ImageMatrix, NonImageMatrix, low, mid - 1);
}
/// <summary>
/// Get the width of the image
/// </summary>
/// <param name="ImageMatrix">2D array that contains the image</param>
/// <returns>Image Width</returns>
public static int GetWidthDouble(MyColorDouble[,] ImageMatrix)
{
return ImageMatrix.GetLength(1);
}
