} //********************** end ColorToGray **********************
public int ColorToGrayMC(CImage inp, Form1 fm1)
/* Transforms the colors of the color image "inp" in lightness=MaxC(r,g,b)
* and puts these values to this.Grid. --------- */
{
int gv, x, y;
if (inp.N_Bits != 24)
{
return(-1);
}
fm1.progressBar1.Visible = true;
N_Bits = 8; width = inp.width; height = inp.height;
Grid = new byte[width * height * 8];
int y1 = 1 + height / 100;
for (y = 0; y < height; y++) //=========================
{
if (y % y1 == 1)
{
fm1.progressBar1.PerformStep();
}
for (x = 0; x < width; x++) // =====================
{
gv = MaxC(inp.Grid[2 + 3 * (x + width * y)],
inp.Grid[1 + 3 * (x + width * y)],
inp.Grid[0 + 3 * (x + width * y)]);
Grid[y * width + x] = (byte)gv;
} // ========== for (x. ====================
}
fm1.progressBar1.Visible = false;
return(1);
} //********************** end ColorToGrayMC **********************
public void Copy(CImage inp)
{
width = inp.width;
height = inp.height;
N_Bits = inp.N_Bits;
for (int i = 0; i < width * height * N_Bits / 8; i++)
{
Grid[i] = inp.Grid[i];
}
}
} //********************** end ColorToGrayMC **********************
public int FastAverageM(CImage Inp, int hWind, Form1 fm1)
// Filters the gray value image "Inp" and returns the result as *this."
{
if (Inp.N_Bits != 8)
{
MessageBox.Show("FastAverageM cannot process an image with " + Inp.N_Bits + " bits per pixel");
return(-1);
}
N_Bits = 8; width = Inp.width; height = Inp.height;
Grid = new byte[width * height];
int[] ColSum; int[] nC;
ColSum = new int[width];
nC = new int[width];
for (int i = 0; i < width; i++)
{
ColSum[i] = nC[i] = 0;
}
int nS = 0, Sum = 0;
fm1.progressBar1.Visible = false;
for (int y = 0; y < height + hWind; y++)
{
int yout = y - hWind, ysub = y - 2 * hWind - 1;
Sum = 0; nS = 0;
int y1 = 1 + (height + hWind) / 100;
for (int x = 0; x < width + hWind; x++)
{
int xout = x - hWind, xsub = x - 2 * hWind - 1; // 1. and 2. addition
if (y < height && x < width)
{
ColSum[x] += Inp.Grid[x + width * y]; nC[x]++;
} // 3. and 4. addition
if (ysub >= 0 && x < width)
{
ColSum[x] -= Inp.Grid[x + width * ysub]; nC[x]--;
}
if (yout >= 0 && x < width)
{
Sum += ColSum[x]; nS += nC[x];
}
if (yout >= 0 && xsub >= 0)
{
Sum -= ColSum[xsub]; nS -= nC[xsub];
}
if (xout >= 0 && yout >= 0)
{
Grid[xout + width * yout] = (byte)((Sum + nS / 2) / nS);
}
}
}
return(1);
} //*************************** end FastAverageM ********************************
private int ImageToBitmapNew(CImage Image, Bitmap bmp, int progPart)
// Any image and color bitmap.
{
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadWrite, bmp.PixelFormat);
if (bmp.PixelFormat != PixelFormat.Format24bppRgb)
{
if (Image.MessReturn("ImageToBitmapNew: we don't use this pixel format") < 0)
{
return(-1);
}
}
IntPtr ptr = bmpData.Scan0;
int size = bmp.Width * bmp.Height;
int length = Math.Abs(bmpData.Stride) * bmp.Height;
byte[] rgbValues = new byte[length];
progressBar1.Visible = true;
int nbyteIm = Image.N_Bits / 8;
for (int y = 0; y < bmp.Height; y++) //=================================================================
{
int jump = bmp.Height / progPart;
if (y % jump == jump - 1)
{
progressBar1.PerformStep();
}
for (int x = 0; x < bmp.Width; x++)
{
Color color = Color.FromArgb(0, 0, 0);;
if (nbyteIm == 3)
{
color = Color.FromArgb(Image.Grid[2 + 3 * (x + Image.width * y)],
Image.Grid[1 + 3 * (x + Image.width * y)], Image.Grid[0 + 3 * (x + Image.width * y)]);
}
else
{
color = Color.FromArgb(Image.Grid[x + Image.width * y],
Image.Grid[x + Image.width * y], Image.Grid[x + Image.width * y]);
}
rgbValues[3 * x + Math.Abs(bmpData.Stride) * y + 0] = color.B;
rgbValues[3 * x + Math.Abs(bmpData.Stride) * y + 1] = color.G;
rgbValues[3 * x + Math.Abs(bmpData.Stride) * y + 2] = color.R;
} //==================================== end for (int x ... =============================
} //===================================== end for (int y ... ===============================
System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, length);
bmp.UnlockBits(bmpData);
return(1);
} //****************************** end ImageToBitmapNew ****************************************
public int SigmaSimpleUni(CImage Inp, int hWind, int Toleranz)
// Simple sigma filter for both gray value and color images.
{
int[] gvMin = new int[3], gvMax = new int[3], nPixel = new int[3], Sum = new int[3];
int c;
N_Bits = Inp.N_Bits;
int nbyte = N_Bits / 8;
for (int y = 0; y < height; y++) // ==================================================
{
int gv, y1, yStart = Math.Max(y - hWind, 0), yEnd = Math.Min(y + hWind, height - 1);
for (int x = 0; x < width; x++) //===============================================
{
int x1, xStart = Math.Max(x - hWind, 0), xEnd = Math.Min(x + hWind, width - 1);
for (c = 0; c < nbyte; c++)
{
Sum[c] = 0; nPixel[c] = 0;
gvMin[c] = Math.Max(0, Inp.Grid[c + nbyte * (x + width * y)] - Toleranz);
gvMax[c] = Math.Min(255, Inp.Grid[c + nbyte * (x + width * y)] + Toleranz);
}
for (y1 = yStart; y1 <= yEnd; y1++)
{
for (x1 = xStart; x1 <= xEnd; x1++)
{
for (c = 0; c < nbyte; c++)
{
gv = Inp.Grid[c + nbyte * (x1 + y1 * width)];
if (gv >= gvMin[c] && gv <= gvMax[c])
{
Sum[c] += gv;
nPixel[c]++;
}
}
}
}
for (c = 0; c < nbyte; c++)
{
if (nPixel[c] > 0)
{
Grid[c + nbyte * (x + width * y)] = (byte)((Sum[c] + nPixel[c] / 2) / nPixel[c]);
}
else
{
Grid[c + nbyte * (x + width * y)] = Inp.Grid[c + nbyte * (x + width * y)];
}
}
} //================== end for (int x... =================================
} //==================== end for (int y... ===================================
return(1);
} //********************** end SigmaSimpleUni **********************************
} //********************** end SigmaSimpleUni **********************************
public int ColorToGray(CImage inp, Form1 fm1)
/* Transforms the colors of the color image "inp" in lightness=(r+g+b)/3
* and puts these values to this.Grid. --------- */
{
int c, sum, x, y;
if (inp.N_Bits != 24)
{
return(-1);
}
fm1.progressBar1.Visible = true;
N_Bits = 8; width = inp.width; height = inp.height;
Grid = new byte[width * height * 8];
int y1 = 1 + height / 100;
for (y = 0; y < height; y++) //=========================
{
if (y % y1 == 1)
{
fm1.progressBar1.PerformStep();
}
for (x = 0; x < width; x++) // =====================
{
sum = 0;
for (c = 0; c < 3; c++)
{
sum += inp.Grid[c + 3 * (x + width * y)];
}
Grid[y * width + x] = (byte)(sum / 3);
} // ========== for (x. ====================
}
fm1.progressBar1.Visible = false;
return(1);
} //********************** end ColorToGray **********************
private void button1_Click(object sender, EventArgs e) // Open image
{
label1.Visible = false;
label2.Visible = false;
label3.Visible = false;
label4.Visible = false;
label5.Visible = false;
label6.Visible = false;
button2.Visible = false;
button3.Visible = false;
button4.Visible = false;
OpenFileDialog openFileDialog1 = new OpenFileDialog();
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
try
{
original_Bitmap = new Bitmap(openFileDialog1.FileName);
OpenImageFile = openFileDialog1.FileName;
pictureBox1.Image = original_Bitmap;
}
catch (Exception ex)
{
MessageBox.Show("Error: Could not read file from disk. Original error: " +
ex.Message);
}
}
else
{
return;
}
label1.Visible = true;
label2.Visible = true;
label5.Visible = true;
label5.Text = "Opened image:" + OpenImageFile;
label6.Visible = true;
button2.Visible = true;
numericUpDown1.Visible = true;
numericUpDown2.Visible = true;
width = original_Bitmap.Width;
height = original_Bitmap.Height;
progressBar1.Visible = true;
progressBar1.Value = 0;
if (original_Bitmap.PixelFormat == PixelFormat.Format8bppIndexed)
{
nbyteBmp = 1;
}
else
if (original_Bitmap.PixelFormat == PixelFormat.Format24bppRgb)
{
nbyteBmp = 3;
}
else
{
MessageBox.Show("Pixel format=" + original_Bitmap.PixelFormat + " not used in this project");
return;
}
nbyteIm = BitmapToImage(original_Bitmap, ref OrigIm);
int N_Bits = nbyteIm * 8;
SigmaIm = new CImage(width, height, N_Bits);
SubIm = new CImage(width, height, N_Bits);
DivIm = new CImage(width, height, N_Bits);
GrayIm = new CImage(width, height, 8);
MeanIm = new CImage(width, height, 8);
BinIm = new CImage(width, height, 8);
SigmaIm.SigmaSimpleUni(OrigIm, 1, 30);
if (OrigIm.N_Bits == 24)
{
GrayIm.ColorToGray(SigmaIm, this);
}
else
{
GrayIm.Copy(SigmaIm);
}
Threshold1 = -1;
Threshold = -1;
ScaleX = (double)pictureBox1.Width / (double)width;
ScaleY = (double)pictureBox1.Height / (double)height;
Scale1 = Math.Min(ScaleX, ScaleY);
marginX = (pictureBox1.Width - (int)(Scale1 * width)) / 2;
marginY = (pictureBox1.Height - (int)(Scale1 * height)) / 2;
progressBar1.Visible = false;
SHADING = false;
} //****************************** end Open image ***************************
} //****************************** end Open image ***************************
public int BitmapToImage(Bitmap bmp, ref CImage Image)
// Converts any bitmap to a color or to a grayscale image.
{
int nbyteIm = 1, rv = 0, x, y;
Color color;
if (nbyteBmp == 1) // nbyteBmp is member of "Form1" according to the PixelFormat of "bmp"
{
x = 10;
y = 2;
color = bmp.GetPixel(x, y);
if (color.R != color.G)
{
nbyteIm = 3;
}
Image = new CImage(bmp.Width, bmp.Height, nbyteIm * 8);
progressBar1.Visible = true;
progressBar1.Value = 0;
for (y = 0; y < bmp.Height; y++) //========================================================
{
int jump = bmp.Height / 100;
if (y % jump == jump - 1)
{
progressBar1.PerformStep();
}
for (x = 0; x < bmp.Width; x++) //======================================================
{
color = bmp.GetPixel(x, y);
if (nbyteIm == 3)
{
Image.Grid[3 * (x + bmp.Width * y) + 0] = color.B;
Image.Grid[3 * (x + bmp.Width * y) + 1] = color.G;
Image.Grid[3 * (x + bmp.Width * y) + 2] = color.R;
}
else // nbyteIm == 1:
{
Image.Grid[x + bmp.Width * y] = color.R;
}
} //================================== end for (x ... ===================================
} //==================================== end for (y ... =====================================
rv = nbyteIm;
}
else // nbyteBmp == 3 and nbyteIm == 3:
{
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadWrite, bmp.PixelFormat);
IntPtr ptr = bmpData.Scan0;
int Str = bmpData.Stride;
int bytes = Math.Abs(bmpData.Stride) * bmp.Height;
byte[] rgbValues = new byte[bytes];
System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes);
nbyteIm = 3;
Image = new CImage(bmp.Width, bmp.Height, nbyteIm * 8);
for (y = 0; y < bmp.Height; y++) //=============================================
{
int jump = bmp.Height / 100;
if (y % jump == jump - 1)
{
progressBar1.PerformStep();
}
for (x = 0; x < bmp.Width; x++)
{
for (int c = 0; c < nbyteIm; c++)
{
Image.Grid[c + nbyteIm * (x + bmp.Width * y)] =
rgbValues[c + nbyteBmp * x + Math.Abs(bmpData.Stride) * y];
}
}
} //========================= end for (y = 0; ... ==============================
rv = nbyteIm;
bmp.UnlockBits(bmpData);
}
return(rv);
} //****************************** end BitmapToImage ****************************************
