static void Main(string[] args)
{
long ms = 0;
Stopwatch timer = new Stopwatch();
timer.Start();
Console.WriteLine("Reading");
var image = new ImageBinarizer("..\\..\\..\\test4.jpg");
PrintTime(timer);
ms += timer.ElapsedMilliseconds;
timer.Restart();
Console.WriteLine("Binarization");
image.StartThresholding();
PrintTime(timer);
ms += timer.ElapsedMilliseconds;
timer.Restart();
Console.WriteLine("Writing");
image.SaveTo("..\\..\\..\\out.bmp");
timer.Stop();
ms += timer.ElapsedMilliseconds;
PrintTime(timer);
Console.WriteLine("Full time: " + ms);
Thread.Sleep(3000);
//Console.ReadKey();
}
private string BinarizeImage(string sourcepath, int imageWidth, int imageHeight, string destinationPath, string name)
{
string binaryImage;
if (!Directory.Exists(destinationPath))
{
Directory.CreateDirectory(destinationPath);
}
string _destinationPath = Path.Combine(destinationPath, $"{name}.jpg");
string _sourcePath = Path.Combine(sourcepath, $"{name}.jpg");
if (File.Exists(_destinationPath))
{
File.Delete(_destinationPath);
}
ImageBinarizer imageBinarizer = new ImageBinarizer(new BinarizerParams {
RedThreshold = 200, GreenThreshold = 200, BlueThreshold = 200, ImageWidth = imageWidth, ImageHeight = imageHeight, InputImagePath = sourcepath, OutputImagePath = _destinationPath
});
imageBinarizer.Run();
binaryImage = imageBinarizer.GetStringBinary();
return(_destinationPath);
}
public void BinarizeImageTest(String sourcePath, String destinationPath)
{
ImageBinarizer imageBinarizer = new ImageBinarizer(new BinarizerParams {
RedThreshold = 200, GreenThreshold = 200, BlueThreshold = 200, ImageWidth = 100, ImageHeight = 100, InputImagePath = sourcePath, OutputImagePath = destinationPath
});
imageBinarizer.Run();
}
/// <summary>
/// Encoding an image with a given full path to a binary array
/// </summary>
/// <param name="inputFile">Input image's full path</param>
/// <returns></returns>
public override int[] Encode(object inputFile)
{
this.binarizerParams.InputImagePath = (string)inputFile;
var binarizer = new ImageBinarizer(binarizerParams);
return(GetArray <int>(binarizer));
}
/// <summary>
/// Creates the instance of the image encoder.
/// </summary>
/// <param name="binarizerParmas"></param>
/// <exception cref="ArgumentException"></exception>
public ImageEncoder(BinarizerParams binarizerParmas)
{
if (binarizerParmas == null)
{
throw new ArgumentException("Invalid encoder setting for ImageEncoder");
}
this.binarizerParams = binarizerParmas;
this.imageBinarizer = new ImageBinarizer(binarizerParmas);
}
public static string Run(string DataDirectoryName)
{
var statistics = new Dictionary <string, int>();
IImageBinarizer binarizer = new ImageBinarizer();
var directoryInfo = new DirectoryInfo(Environment.CurrentDirectory).Parent.Parent.Parent;
var path = Path.Combine(directoryInfo.FullName, DataDirectoryName);
directoryInfo = new DirectoryInfo(path);
imageClassifier = new ImageClassifier(binarizer, Size * Size);
//Train
foreach (DirectoryInfo directory in directoryInfo.EnumerateDirectories())
{
foreach (var file in directory.EnumerateFiles("*.bmp"))
{
string fileName = Path.GetFileNameWithoutExtension(file.FullName);
imageClassifier.Train(new ImageUnit {
Id = fileName, Image = new Bitmap(file.FullName)
});
}
}
foreach (DirectoryInfo directory in directoryInfo.EnumerateDirectories())
{
foreach (var file in directory.EnumerateFiles("*.bmp"))
{
string fileName = Path.GetFileNameWithoutExtension(file.FullName);
var patternDirectory = directory.EnumerateDirectories().FirstOrDefault(p => p.Name == ("Randomized_" + fileName));
foreach (var patternFile in patternDirectory.EnumerateFiles("*.bmp"))
{
string patternFileName = Path.GetFileNameWithoutExtension(patternFile.FullName);
string[] nameParts = patternFileName.Split(new[] { "_" }, StringSplitOptions.RemoveEmptyEntries);
string percentValue = nameParts[1];
if (statistics.ContainsKey(percentValue) == false)
{
statistics.Add(percentValue, 0);
}
string classificationResult = imageClassifier.Classify(new Bitmap(patternFile.FullName));
if (classificationResult.Equals(fileName, StringComparison.CurrentCulture))
{
statistics[percentValue] += 1;
}
}
}
}
return(statistics.Aggregate("Classification result: \n\n", (current, statistic) => current + String.Format("Noise percent: {0}\n Matched: {1}\n\n", statistic.Key, statistic.Value)));
}
/// <summary>
/// Binarize image to binarizedImage.
/// </summary>
/// <param name="mnistImage"></param>
/// <param name="imageSize"></param>
/// <param name="testName"></param>
/// <returns></returns>
private static string BinarizeImage(string mnistImage, int imageSize, string testName)
{
string binaryImage = $"{testName}.txt";
if (File.Exists(binaryImage))
{
File.Delete(binaryImage);
}
ImageBinarizer imageBinarizer = new ImageBinarizer(new BinarizerParams {
RedThreshold = 200, GreenThreshold = 200, BlueThreshold = 200, ImageWidth = imageSize, ImageHeight = imageSize, InputImagePath = mnistImage, OutputImagePath = binaryImage
});
imageBinarizer.Run();
return(binaryImage);
}
/// <summary>
/// Method to convert GetArrayBinary from data type double[,,] to int[]
/// </summary>
/// <returns></returns>
private static T[] GetArray <T>(ImageBinarizer imageBinarizer)
{
var doubleArray = imageBinarizer.GetArrayBinary();
var hg = doubleArray.GetLength(1);
var wd = doubleArray.GetLength(0);
T[] intArray = new T[hg * wd];
for (int j = 0; j < hg; j++)
{
for (int i = 0; i < wd; i++)
{
intArray[j * wd + i] = (T)Convert.ChangeType(doubleArray[i, j, 0], typeof(int));
}
}
return(intArray);
}
/// <summary>
/// Binarize image to create an binarized image and return the path to that binarized image.
/// </summary>
/// <param name="mnistImage"> Path to the source mnist image</param>
/// <param name="imageSize">Size of the image (image has same width and height)</param>
/// <returns>Path to the output binarized image</returns>
private static string BinarizeImage(string mnistImage, int imageSize)
{
var binaryImage = $@"Output\{GetFileName(mnistImage)}.txt";
Directory.CreateDirectory($"Output");
if (File.Exists(binaryImage))
{
File.Delete(binaryImage);
}
ImageBinarizer imageBinarizer = new ImageBinarizer(new BinarizerParams {
RedThreshold = 200, GreenThreshold = 200, BlueThreshold = 200, ImageWidth = imageSize, ImageHeight = imageSize, InputImagePath = mnistImage, OutputImagePath = binaryImage
});
imageBinarizer.Run();
return(binaryImage);
}
