public void SetImageHistogram(ImageHistogram imageHistogram)
{
if (imageHistogram == null)
{
return;
}
this.imageHistogram = imageHistogram;
xMin = 0;
xMax = 256;
yMin = 0;
yMax = this.imageHistogram.PixelNumberList.Max();
SetScales();
Invalidate();
}
private void ApplyHistButton_Click(object sender, EventArgs e)
{
if (HistMatchCheck.Checked)
{
Bitmap Img1 = new Bitmap(SourceBox.Text);
Bitmap Img2 = new Bitmap(TargetBox.Text);
Bitmap newImg = ImageHistogram.histMatching(Img1, Img2);
AfterBox.Image = newImg;
refreshHistograms();
return;
}
Bitmap B;
if (sourceBitmap == null)
{
return;
}
B = new Bitmap(sourceBitmap);
ImageHistogram imageHist = new ImageHistogram(B);
if (GrayCheck.Checked)
{
imageHist.grayScale();
}
if (BrightCheck.Checked)
{
imageHist.changeBrightness(int.Parse(BrightBox.Text));
}
if (ContrastCheck.Checked)
{
imageHist.changeContrast(int.Parse(ContrastMinBox.Text), (int.Parse(ContrastMaxBox.Text)));
}
if (GammaCheck.Checked)
{
imageHist.changeGamma(double.Parse(GammaBox.Text));
}
if (HistEqCheck.Checked)
{
imageHist.histEqualization();
}
AfterBox.Image = imageHist.getImage();
refreshHistograms();
}
private void refreshHistograms()
{
RedHistogramChart.Series.Clear();
RedHistogramChart.Series.Add("Pixel Values");
GreenHistogramChart.Series.Clear();
GreenHistogramChart.Series.Add("Pixel Values");
BlueHistogramChart.Series.Clear();
BlueHistogramChart.Series.Add("Pixel Values");
GrayHistogramChart.Series.Clear();
GrayHistogramChart.Series.Add("Pixel Values");
ImageHistogram imageHist = new ImageHistogram(new Bitmap(AfterBox.Image));
imageHist.calcHist();
Random r = new Random();
int maxR = 0;
int maxG = 0;
int maxB = 0;
int maxGray = 0;
for (int i = 0; i < 255; i++)
{
maxR = Math.Max(imageHist.redHist[i], maxR);
maxG = Math.Max(imageHist.greenHist[i], maxG);
maxB = Math.Max(imageHist.blueHist[i], maxB);
maxGray = Math.Max(imageHist.grayHist[i], maxGray);
}
for (int i = 0; i < 255; i++)
{
GrayHistogramChart.Series[0].Points.Add(imageHist.grayHist[i] / (double)maxGray);
RedHistogramChart.Series[0].Points.Add(imageHist.redHist[i] / (double)maxR);
GreenHistogramChart.Series[0].Points.Add(imageHist.greenHist[i] / (double)maxG);
BlueHistogramChart.Series[0].Points.Add(imageHist.blueHist[i] / (double)maxB);
}
}
public static void EqualizeHistogram(FastBitmap bmp, EqualizationMethod method)
{
ImageHistogram hist = new ImageHistogram(bmp);
int R = 0;
double hInt = 0.0;
double[] left = new double[256];
double[] right = new double[256];
int[] newValue = new int[256];
for (int i = 0; i < 256; ++i)
{
left[i] = R;
hInt += hist.table[i];
while (hInt > hist.average)
{
hInt -= hist.average;
if (R < 255)
R++;
}
right[i] = R;
switch (method)
{
case EqualizationMethod.Averages:
newValue[i] = (int)((left[i] + right[i]) / 2.0);
break;
case EqualizationMethod.Random:
newValue[i] = (int)(right[i] - left[i]);
break;
case EqualizationMethod.Own:
newValue[i] = (int)((left[i] + right[i]) / 2.0);
break;
}
}
for (int i = 0; i < bmp.Size.Width; ++i)
{
for (int j = 0; j < bmp.Size.Height; ++j)
{
Color color = bmp[i, j];
if (left[color.R] == right[color.R])
bmp[i, j] = Color.FromArgb(color.A, (int)left[color.R], (int)left[color.R], (int)left[color.R]);
else
{
switch (method)
{
case EqualizationMethod.Averages:
bmp[i, j] = Color.FromArgb(color.A, (int)newValue[color.R], (int)newValue[color.R], (int)newValue[color.R]);
break;
case EqualizationMethod.Random:
Random rnd = new Random();
int value = (int)left[color.R] + rnd.Next(newValue[color.R] + 1);
bmp[i, j] = Color.FromArgb(color.A, value, value, value);
break;
case EqualizationMethod.Neighborhood8:
double average = 0;
int count = 0;
foreach (Point offset in new Point[] { new Point(1, 0), new Point(-1, 0), new Point(0, 1), new Point(0, -1), new Point(1, 1), new Point(-1, -1), new Point(-1, 1), new Point(1, -1) })
{
if (i + offset.X >= 0 && i + offset.X < bmp.Width && j + offset.Y >= 0 && j + offset.Y < bmp.Height)
{
average += bmp[i + offset.X, j + offset.Y].R;
++count;
}
}
average /= count;
if (average > right[color.R])
bmp[i, j] = Color.FromArgb(color.A, (int)right[color.R], (int)right[color.R], (int)right[color.R]);
else if (average < left[color.R])
bmp[i, j] = Color.FromArgb(color.A, (int)left[color.R], (int)left[color.R], (int)left[color.R]);
else
bmp[i, j] = Color.FromArgb(color.A, (int)average, (int)average, (int)average);
break;
case EqualizationMethod.Own:
bmp[i, j] = Color.FromArgb(color.A, (int)newValue[color.R], (int)newValue[color.R], (int)newValue[color.R]);
break;
}
}
}
}
}
private void histogramToolStripMenuItem_Click(object sender, EventArgs e)
{
ImagePreview imageForm = (ImagePreview)this.ActiveMdiChild;
ImageHistogram imageHistogram = new ImageHistogram(imageForm.Image);
imageHistogram.MdiParent = this;
imageHistogram.Show();
/*HistogramWindow imageHistogram = new HistogramWindow();
imageHistogram.GatherStatistics(bitmap);
imageHistogram.Show();
imageHistogram.MdiParent = this;*/
}
/// <summary>
/// Calculate imilarity stats when images are changed
/// </summary>
private void ImageSimilarityStats()
{
// update image similarity stats
if (image1 != null && image2 != null)
{
if (image_changed)
{
UpdateImages();
image_changed = false;
// reduce image size for calculation
var smaller_image1 = CommonUtils.ImageUtils.Resize(image1, smaller_img_size.Width, smaller_img_size.Height, false);
var smaller_image2 = CommonUtils.ImageUtils.Resize(image2, smaller_img_size.Width, smaller_img_size.Height, false);
// compare dominant colors
var top_color1 = Images.ColorExtract.TopColors(image1);
var top_color1_img = (Image)Images.ColorExtract.Draw(top_color1, Images.ColorExtract.top_colors * 2, 4);
var top_color2 = Images.ColorExtract.TopColors(image2);
var top_color2_img = (Image)Images.ColorExtract.Draw(top_color2, Images.ColorExtract.top_colors * 2, 4);
var main_color1_img = Images.ColorExtract.Draw(top_color1, 1, 2);
var main_color2_img = Images.ColorExtract.Draw(top_color2, 1, 2);
double dcolor_similarity = Images.ImageSimilarity.CompareImages(top_color1_img, top_color2_img, method: ComparisonMethod.PixelsDifferenceSorted);
pictureBox_DominantColor1.Image = top_color1_img;
pictureBox_DominantColor1.Refresh();
pictureBox_Color1.Image = main_color1_img;
pictureBox_Color1.Refresh();
pictureBox_DominantColor2.Image = top_color2_img;
pictureBox_DominantColor2.Refresh();
pictureBox_Color2.Image = main_color2_img;
pictureBox_Color2.Refresh();
UpdateSimilarityLabel(labelDominantColors_similarity, dcolor_similarity);
// compare average hash
double avghash_similarity = Images.ImageHash.Compare(smaller_image1, smaller_image2, Images.ImageHashAlgorithm.Average);
UpdateSimilarityLabel(label_AvgHash_similarity, avghash_similarity);
// compare block hash
double blockhash_similarity = Images.ImageHash.Compare(image1, image2, Images.ImageHashAlgorithm.Block);
UpdateSimilarityLabel(label_BlockHash_similarity, blockhash_similarity);
// compare difference hash
double diffhash_similarity = Images.ImageHash.Compare(smaller_image1, smaller_image2, Images.ImageHashAlgorithm.Difference);
UpdateSimilarityLabel(label_DiffHash_similarity, diffhash_similarity);
// compare perceptual hash
double phash_similarity = Images.ImageHash.Compare(smaller_image1, smaller_image2, Images.ImageHashAlgorithm.Perceptive);
UpdateSimilarityLabel(label_PHash_similarity, phash_similarity);
// compare MD5 hash
double md5hash_similarity = Images.ImageHash.Compare(smaller_image1, smaller_image2, Images.ImageHashAlgorithm.MD5);
UpdateSimilarityLabel(label_MD5Hash_similarity, md5hash_similarity);
// RGB histograms
var rgb1_bmp = ImageHistogram.DrawRgbHistogramChart(smaller_image1);
pictureBox_RGB1.Image = CommonUtils.ImageUtils.Resize(rgb1_bmp, rgb_img_size);
pictureBox_RGB1.Refresh();
var rgb2_bmp = ImageHistogram.DrawRgbHistogramChart(smaller_image2);
pictureBox_RGB2.Image = CommonUtils.ImageUtils.Resize(rgb2_bmp, rgb_img_size);
pictureBox_RGB2.Refresh();
rgb1_bmp.Dispose();
rgb2_bmp.Dispose();
// RGB avg histogram
double rgb_avg_similarity = ImageHistogram.CompareAvgRgbHistogram(smaller_image1, smaller_image2);
UpdateSimilarityLabel(label_RGBHistogramAverage_similarity, rgb_avg_similarity);
// RGB histogram
double rgb_similarity = ImageHistogram.CompareRgbHistogram(smaller_image1, smaller_image2);
UpdateSimilarityLabel(label_RGBHistogram_similarity, rgb_similarity);
// RGB hash
double rgb_hash_similarity = Images.ImageHash.Compare(smaller_image1, smaller_image2, Images.ImageHashAlgorithm.Histogram);;
UpdateSimilarityLabel(label_HistogramHash_similarity, rgb_hash_similarity);
// RGB pixels similarity
double rgb_pixels_similarity = ImageSimilarity.CompareImages(smaller_image1, smaller_image2, ComparisonMethod.PixelsDifference);
UpdateSimilarityLabel(label_DiffPixelsRgb_similarity, rgb_pixels_similarity);
double rgb_pixels_similarity_sorted = ImageSimilarity.CompareImages(smaller_image1, smaller_image2, ComparisonMethod.PixelsDifferenceSorted);
UpdateSimilarityLabel(label_DiffPixelsRgb_sorted_similarity, rgb_pixels_similarity_sorted);
double dist_rgb_pixels_similarity = ImageSimilarity.CompareImages(smaller_image1, smaller_image2, ComparisonMethod.PixelsDistance);
UpdateSimilarityLabel(label_DistPixelsRgb_similarity, dist_rgb_pixels_similarity);
double dist_rgb_pixels_similarity_sorted = ImageSimilarity.CompareImages(smaller_image1, smaller_image2, ComparisonMethod.PixelsDistanceSorted);
UpdateSimilarityLabel(label_DistPixelsRgb_sorted_similarity, dist_rgb_pixels_similarity_sorted);
// feature detection
double nfeature = 0;
double nmatch = 0;
Bitmap view;
double feature_similarity = ImageSimilarity.CompareFeatures(image1, image2, out nfeature, out nmatch, out view);
//pictureBox_Feature.Image = CommonUtils.ImageUtils.Resize(view, feature_img_size,true);
pictureBox_Feature.Image = CommonUtils.ImageUtils.Resize(view, feature_img_size.Width, feature_img_size.Height);
pictureBox_Feature.Refresh();
label_FeatureStats.Text = String.Format("{0} match", ((int)nmatch));
//label_FeatureStats.Text = ((int)nmatch).ToString();
label_FeatureStats.Refresh();
UpdateSimilarityLabel(this.label_Feature_similarity, feature_similarity);
// GC.Collect(); // force GC to free memory
// GC.WaitForPendingFinalizers();
}
} // have 0 or 1 images
else
{
//update images
UpdateImages();
}
}
