public void BinarizerTest()
{
string trainingImagesPath = Path.Combine(Path.Combine(AppContext.BaseDirectory, "MLPerceptron"), "TrainingImages");
Binarizer bizer = new Binarizer();
bizer.CreateBinary(Path.Combine(trainingImagesPath, "1 (168).jpeg"), "binary.txt");
}
/// <summary>
/// Returns Binarized Image in integer array and creates file of Binarized Image
/// </summary>
/// <param name="imageName">Name of Image to be binarized</param>
/// <param name="height">Height of Binarized Image</param>
/// <param name="width">Width of Binarized Image</param>
/// <returns></returns>
public int[] ReadImageData(String imageName, int height, int width)
{
Binarizer bizer = new Binarizer(targetHeight: height, targetWidth: width);
var imgName = Path.Combine(Path.Combine(AppContext.BaseDirectory, "Images"), imageName);
bizer.CreateBinary(imgName, Path.Combine(Path.Combine(AppContext.BaseDirectory, "Output"), $"bin-{imageName}.txt"));
var binaryString = bizer.GetBinary(imgName);
int[] intArray = new int[height * width];
int j = 0;
for (int i = 0; i < binaryString.Length; i++)
{
if (binaryString[i].Equals('0'))
{
intArray[j] = 0;
j++;
}
else if (binaryString[i].Equals('1'))
{
intArray[j] = 1;
j++;
}
}
return(intArray);
}
private string BinarizeImage(string sourcepath, int imageWidth, int imageHeight, string destinationPath, string name)
{
string binaryImage;
Binarizer imageBinarizer = new Binarizer(200, 200, 200, imageWidth, imageHeight);
//binaryImage = $"{testName}.txt";
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.CreateBinary(_sourcePath, _destinationPath);
binaryImage = imageBinarizer.GetBinary(_sourcePath);
// Console.WriteLine(binaryImage);
//int[] vector =
return(_destinationPath);
}
public void BinarizeImageTest(String sourcePath, String destinationPath)
{
Binarizer imageBinarizer = new Binarizer(200, 200, 200, 32, 32);
imageBinarizer.CreateBinary(sourcePath, destinationPath);
string res = imageBinarizer.GetBinary(sourcePath);
}
// Read image and convert to binary format
private string readImageData(string imageName, int width, int height)
{
//string trainingImagesPath = Path.Combine(Path.Combine(AppContext.BaseDirectory, "RestrictedBolzmannMachine"), "TrainingImages");
Binarizer bizer = new Binarizer(targetHeight: height, targetWidth: width);
//return bizer.GetBinary(Path.Combine(trainingImagesPath, imageName));
return(bizer.GetBinary(imageName));
}
public BinaryBitmap(Binarizer binarizer)
{
if (binarizer == null)
{
throw new ArgumentException("Binarizer must be non-null.");
}
this.binarizer = binarizer;
}
public BinaryBitmap(Binarizer binarizer)
{
if (binarizer == null)
{
throw new System.ArgumentException("Binarizer must be non-null.");
}
this.binarizer = binarizer;
matrix = null;
}
public IplImage BinarizerMethod(IplImage src)
{
bina = new IplImage(src.Size, BitDepth.U8, 1);
gray = this.GrayScale(src);
Binarizer.Bernsen(gray, bina, 52, 60, 150);
return(bina);
}
public void BinarizerWithTargetSizeTest()
{
Binarizer bizer = new Binarizer(targetHeight: 256, targetWidth: 256);
foreach (var item in new string[] { "face.jpg", "daenet.png", "gab.png" })
{
string trainingImagesPath = Path.Combine(Path.Combine(AppContext.BaseDirectory, "ImageBinarization"), "TestImages");
bizer.CreateBinary(Path.Combine(trainingImagesPath, item), $"binary__256x256_{item}.txt");
}
}
public void BinarizerTest()
{
Binarizer bizer = new Binarizer();
foreach (var item in new string[] { "face.jpg", "daenet.png", "gab.png" })
{
string trainingImagesPath = Path.Combine(Path.Combine(AppContext.BaseDirectory, "ImageBinarization"), "TestImages");
bizer.CreateBinary(Path.Combine(trainingImagesPath, item), $"binary_{item}.txt");
}
}
public static string parse(Binarizer bin)
{
var bitmap = new BinaryBitmap(bin);
var reader = new ZXing.QrCode.QRCodeReader();
var result = reader.decode(bitmap);
if (result == null)
{
return(null);
}
return(result.Text);
}
public BinarizationMethods()
{
const int Size = 61;
using (var imgSrc = new IplImage(FilePath.Image.Binarization, LoadMode.GrayScale))
using (var imgGauss = imgSrc.Clone())
using (var imgNiblack = new IplImage(imgSrc.Size, BitDepth.U8, 1))
using (var imgSauvola = new IplImage(imgSrc.Size, BitDepth.U8, 1))
using (var imgBernsen = new IplImage(imgSrc.Size, BitDepth.U8, 1))
using (var imgNick = new IplImage(imgSrc.Size, BitDepth.U8, 1))
{
//Cv.Smooth(imgSrc, imgGauss, SmoothType.Gaussian, 9);
//Cv.EqualizeHist(imgGauss, imgGauss);
Stopwatch sw = Stopwatch.StartNew();
{
const double K = -0.2;
Binarizer.NiblackFast(imgGauss, imgNiblack, Size, K);
}
Console.WriteLine("Niblack: {0}ms", sw.ElapsedMilliseconds);
sw.Reset(); sw.Start();
{
const double K = 0.2;
const double R = 64;
Binarizer.SauvolaFast(imgGauss, imgSauvola, Size, K, R);
}
Console.WriteLine("Sauvola: {0}ms", sw.ElapsedMilliseconds);
sw.Reset(); sw.Start();
{
const byte ContrastMin = 15;
const byte BgThreshold = 127;
Binarizer.Bernsen(imgGauss, imgBernsen, Size, ContrastMin, BgThreshold);
}
Console.WriteLine("bernsen: {0}ms", sw.ElapsedMilliseconds);
sw.Reset(); sw.Start();
{
const double K = -0.14;
Binarizer.Nick(imgGauss, imgNick, Size, K);
}
Console.WriteLine("nick: {0}ms", sw.ElapsedMilliseconds);
using (new CvWindow("src", imgSrc))
//using (new CvWindow("gauss", imgGauss))
using (new CvWindow("niblack", imgNiblack))
using (new CvWindow("sauvola", imgSauvola))
using (new CvWindow("bernsen", imgBernsen))
using (new CvWindow("nick", imgNick))
{
Cv.WaitKey();
}
}
}
public void TestBinarizeFromColorPng()
{
Stream bitmapStream = Assembly.GetAssembly(this.GetType()).GetManifestResourceStream("CSammisRun.Imaging.Test.Resources.10x20checkerboardARGB.png");
Assert.IsNotNull(bitmapStream);
Bitmap resourceBitmap = new Bitmap(bitmapStream);
Assert.IsNotNull(resourceBitmap, "Bitmap could not be constructed from resource.");
Assert.AreEqual(PixelFormat.Format32bppArgb, resourceBitmap.PixelFormat, "Resource bitmap has unexpected pixel format.");
Binarizer binarizer = new Binarizer { Threshold = 750 };
Bitmap testBitmap = binarizer.ProcessImage(resourceBitmap);
DoCommonAssertationsOnCheckboardResult(testBitmap);
}
/// <summary>
/// Binarize image to binarizedImage.
/// </summary>
/// <param name="mnistImage"></param>
/// <param name="imageSize"></param>
/// <param name="testName"></param>
/// <returns></returns>
public static string BinarizeImage(string mnistImage, int imageSize, string testName)
{
string binaryImage;
Binarizer imageBinarizer = new Binarizer(200, 200, 200, imageSize, imageSize);
binaryImage = $"{testName}.txt";
if (File.Exists(binaryImage))
{
File.Delete(binaryImage);
}
imageBinarizer.CreateBinary(mnistImage, binaryImage);
return(binaryImage);
}
/// <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)
{
string binaryImage;
Binarizer binarizer = new Binarizer(200, 200, 200, imageSize, imageSize);
binaryImage = $@"Output\{GetFileName(mnistImage)}.txt";
Directory.CreateDirectory($"Output");
if (File.Exists(binaryImage))
{
File.Delete(binaryImage);
}
binarizer.CreateBinary(mnistImage, binaryImage);
return(binaryImage);
}
public void Run()
{
using (var src = Cv2.ImRead(FilePath.Image.Binarization, ImreadModes.GrayScale))
using (var niblack = new Mat())
using (var sauvola = new Mat())
using (var bernsen = new Mat())
using (var nick = new Mat())
{
int kernelSize = 51;
var sw = new Stopwatch();
sw.Start();
Binarizer.Niblack(src, niblack, kernelSize, -0.2);
sw.Stop();
Console.WriteLine($"Niblack {sw.ElapsedMilliseconds} ms");
sw.Restart();
Binarizer.Sauvola(src, sauvola, kernelSize, 0.1, 64);
sw.Stop();
Console.WriteLine($"Sauvola {sw.ElapsedMilliseconds} ms");
sw.Restart();
Binarizer.Bernsen(src, bernsen, kernelSize, 50, 200);
sw.Stop();
Console.WriteLine($"Bernsen {sw.ElapsedMilliseconds} ms");
sw.Restart();
Binarizer.Nick(src, nick, kernelSize, -0.14);
sw.Stop();
Console.WriteLine($"Nick {sw.ElapsedMilliseconds} ms");
using (new Window("src", WindowMode.AutoSize, src))
using (new Window("Niblack", WindowMode.AutoSize, niblack))
using (new Window("Sauvola", WindowMode.AutoSize, sauvola))
using (new Window("Bernsen", WindowMode.AutoSize, bernsen))
using (new Window("Nick", WindowMode.AutoSize, nick))
{
Cv2.WaitKey();
}
}
}
public void Run()
{
using var src = Cv2.ImRead(FilePath.Image.Binarization, ImreadModes.Grayscale);
using var niblack = new Mat();
using var sauvola = new Mat();
using var bernsen = new Mat();
using var nick = new Mat();
int kernelSize = 51;
var sw = new Stopwatch();
sw.Start();
CvXImgProc.NiblackThreshold(src, niblack, 255, ThresholdTypes.Binary, kernelSize, -0.2, LocalBinarizationMethods.Niblack);
sw.Stop();
Console.WriteLine($"Niblack {sw.ElapsedMilliseconds} ms");
sw.Restart();
CvXImgProc.NiblackThreshold(src, sauvola, 255, ThresholdTypes.Binary, kernelSize, 0.1, LocalBinarizationMethods.Sauvola);
sw.Stop();
Console.WriteLine($"Sauvola {sw.ElapsedMilliseconds} ms");
sw.Restart();
Binarizer.Bernsen(src, bernsen, kernelSize, 50, 200);
sw.Stop();
Console.WriteLine($"Bernsen {sw.ElapsedMilliseconds} ms");
sw.Restart();
CvXImgProc.NiblackThreshold(src, nick, 255, ThresholdTypes.Binary, kernelSize, -0.14, LocalBinarizationMethods.Nick);
sw.Stop();
Console.WriteLine($"Nick {sw.ElapsedMilliseconds} ms");
using (new Window("src", src, WindowFlags.AutoSize))
using (new Window("Niblack", niblack, WindowFlags.AutoSize))
using (new Window("Sauvola", sauvola, WindowFlags.AutoSize))
using (new Window("Bernsen", bernsen, WindowFlags.AutoSize))
using (new Window("Nick", nick, WindowFlags.AutoSize))
{
Cv2.WaitKey();
}
}
private string readImageData(string imageName, int width, int height)
{
Binarizer bizer = new Binarizer(targetHeight: height, targetWidth: width);
return(bizer.GetBinary(imageName));
}
public static void Binarize(Mat mat, int blockSize, Mat res)
{
Cv2.CvtColor(mat, tmp, ColorConversionCodes.RGB2GRAY);
Binarizer.Sauvola(tmp, res, blockSize, 0.15, 32);
}
