public void Blur()
{
foreach (int neighborDist in new int[] { 1, 3, 6 })
{
{
foreach (KeyValuePair <string, Bitmap> entry in AllImages)
{
Bitmap bmp = entry.Value;
ImageManipulator im = new ImageManipulator(bmp);
im.Blur(neighborDist);
Bitmap answer = new Bitmap($"{BaseDir}\\Resources\\Answers\\Blur" + neighborDist + entry.Key);
bool passed = BmpsAreEqual(im.ToBitmap(), answer);
if (!passed)
{
im.ToBitmap().Save($"{BaseDir}\\TestOutput\\Filter" + entry.Key + " ImageManipulator.png");
}
Assert.IsTrue(passed, $"{entry.Key} failed at brightness ${neighborDist}");
}
}
}
}
public Screens WhatScreenAmIOn()
{
var current = CaptureBrowser();
var imageWorker = new ImageManipulator();
var login = imageWorker.PercentMatch(current, LoginTrainer);
var home = imageWorker.PercentMatch(current, HomeTrainer);
var transferHome = imageWorker.PercentMatch(current, TransferHomeTrainer);
var transferSearch = imageWorker.PercentMatch(current, TransferSearchTrainer);
var eaLogin = imageWorker.PercentMatch(current, EaLoginTrainer);
current.Dispose();
var dict = new Dictionary <Screens, decimal>
{
{ Screens.Login, login },
{ Screens.Home, home },
{ Screens.TransferHome, transferHome },
{ Screens.TransferSearch, transferSearch },
{ Screens.EaSignIn, eaLogin }
};
var screen = dict.OrderByDescending(x => x.Value).FirstOrDefault().Key;
return(dict[screen] <= 65 ? Screens.Inconclusive : screen);
}
public IHttpActionResult GetImage(DateTime dateTime, string fileName)
{
var endpoint = LocationToUrl.ConvertPathToUrl(fileName, dateTime);
var missingList = DetectedPlateHelper.GetDetectedPlatesByImgUrl(endpoint)
.Select(dlp => MissingPlateHelper.GetPlateRecordByPlateNumber(dlp.PlateNumber))
.Where(mlpList => 0 != mlpList.Count())
.Where(mlpList => mlpList.Where(mlp => mlp.Status == LicensePlateFoundStatus.Searching).Any())
.ToList();
if (!missingList.Any())
{
throw new AccessViolationException(Resources.Error_FileAccessDenied);
}
var folderLocation = ImageManipulator.GenerateFolderLocationPath(dateTime);
//TODO: Add regex check for ../
var filePath = Path.Combine(folderLocation, fileName) + ".jpg";
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StreamContent(File.OpenRead(filePath)),
StatusCode = HttpStatusCode.OK
};
response.Content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg");
return(ResponseMessage(response));
}
public async Task SaveAsync(int categoryId, string base64Img)
{
var categoryE = await CategoryRepository.FindAsync(categoryId) ?? throw new Exception();
if (!ImageManipulator.IsImageStream(base64Img))
{
throw new Exception();
}
var buffer = Convert.FromBase64String(base64Img);
var resizedImgBuffer = ImageManipulator.ResizeImage(
buffer,
Options.CategoryThumbnail.Width,
Options.CategoryThumbnail.Height,
Options.CategoryThumbnail.ImageFormat);
var hash = Md5Hasher.GenerateBase16Hash(resizedImgBuffer);
var randomizedHash = Randomize(hash);
var fileName = string.Format("{0}.{1}", randomizedHash, Options.CategoryThumbnail.ImageFormat.ToString());
await BlobContainer.DeleteAsync(categoryE.CategoryThumbnail);
await BlobContainer.SaveBytesAsync(fileName, resizedImgBuffer);
categoryE.CategoryThumbnail = fileName;
await CategoryRepository.UpdateAsync(categoryE, autoSave : true);
}
public async Task <SlideShowPictureDto> UpdateAsync(string fileName, SlideShowPictureDto dto)
{
if (string.IsNullOrWhiteSpace(fileName) ||
!ImageManipulator.IsImageStream(dto.Base64Picture))
{
throw new ArgumentException();
}
var b64Part = (dto.Base64Picture == null)? null : GetBase64Part(dto.Base64Picture);
var file = await BlobContainer.GetAllBytesOrNullAsync(fileName) ?? throw new FileNotFoundException();
var xmlDoc = new XmlDocument();
var settings = GetReaderSettings();
using var ms = new MemoryStream(file);
using var reader = XmlReader.Create(ms, settings);
xmlDoc.Load(reader);
var slideShowElm = xmlDoc.DocumentElement;
var imgElm = slideShowElm.FirstChild;
var b64txtNode = imgElm.FirstChild as XmlText;
b64txtNode.InnerText = b64Part ?? b64txtNode.InnerText;
slideShowElm.SetAttribute("uri", (dto.Uri == null) ? slideShowElm.GetAttribute("uri") : dto.Uri.ToString());
slideShowElm.SetAttribute("name", dto.Name ?? slideShowElm.GetAttribute("name"));
var bytes = Encoding.UTF8.GetBytes(xmlDoc.InnerXml);
await BlobContainer.SaveAsync(fileName, bytes, true);
return(await GetAsync(fileName));
}
private void ShowHistogram()
{
var histogramView = new HistogramView();
histogramView.DataContext = new HistogramViewModel(ImageManipulator.GenerateImageHistogram(_originalImage), ImageManipulator.EqualizeHistogram(_originalImage));
histogramView.ShowDialog();
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
var data = await req.Content.ReadAsStreamAsync();
using (var outStream = new MemoryStream())
{
// Do stuff here
var scaledBitmap = ImageManipulator.ScaleTo(data, 300, 300);
using (var tempStream1 = new MemoryStream())
{
scaledBitmap.Save(tempStream1, ImageFormat.Png);
var croppedBitmap = ImageManipulator.Crop(tempStream1, 300, 300);
using (var tempStream2 = new MemoryStream())
{
croppedBitmap.Save(tempStream2, ImageFormat.Png);
//var proc = new ImageProcessor.ImageFactory();
//proc.Load(tempStream2.ToArray()).RoundedCorners(150).Save(outStream);
var result = new HttpResponseMessage(HttpStatusCode.OK);
//result.Content = new ByteArrayContent(outStream.ToArray());
result.Content = new ByteArrayContent(tempStream2.ToArray());
result.Content.Headers.Add("Content-Type", "application/octet-stream");
return(result);
}
}
}
}
public void Rotate()
{
foreach (KeyValuePair <string, Bitmap> entry in AllImages)
{
Bitmap bmp = entry.Value;
ImageManipulator im = new ImageManipulator(bmp);
MagickImage mi = new MagickImage(bmp);
for (int rotates = 1; rotates < 6; rotates++)
{
foreach (bool clockwise in (new bool[] { true, false }))
{
im.Rotate(rotates, clockwise);
int degrees = rotates * 90;
if (!clockwise)
{
degrees += 180;
}
mi.Rotate(degrees);
bool passed = BmpsAreEqual(im.ToBitmap(), mi.ToBitmap());
if (!passed)
{
im.ToBitmap().Save($"{BaseDir}\\TestOutput\\Rotate" + entry.Key + " " + degrees + " ImageManipulator.png");
mi.ToBitmap().Save($"{BaseDir}\\TestOutput\\Rotate" + entry.Key + " MagickImage.png");
}
Assert.IsTrue(passed, $"{entry.Key} failed rotation at {degrees} degrees");
}
}
}
}
/// <summary>
/// Draws the background of the parent control giving a transparent effect
/// </summary>
/// <param name="graphics">Drawing surface</param>
/// <param name="form">Parent Container that implements <see cref="IControlBackground"/></param>
/// <param name="bounds">Bounds of the Control</param>
/// <param name="parent">Instance of the Parent Container</param>
public void DrawBackground(Graphics graphics, IControlBackground form, Rectangle bounds, Control parent)
{
if (form.BackgroundImage == null)
{
return;
}
var g = GraphicsEx.FromGraphics(graphics);
switch (form.BackgroundDrawMode)
{
case ImageDrawMode.Normal:
g.DrawImage(form.BackgroundImage, 0, 0, bounds);
break;
case ImageDrawMode.Center:
Point location = GraphicsEx.GetCenter(form.BackgroundImage.Size, parent.ClientSize);
g.DrawImage(form.BackgroundImage,
location.X,
location.Y,
new Rectangle(bounds.X,
bounds.Y,
form.BackgroundImage.Width,
form.BackgroundImage.Height));
break;
case ImageDrawMode.Stretch:
using (Image image = ImageManipulator.Stretch(form.BackgroundImage, parent.ClientSize))
g.DrawImage(image, 0, 0, bounds);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public InterruptScreen IsProcessingInterrupted()
{
var imageWorker = new ImageManipulator();
var messageCapture = CaptureCaptchaResults();
var captcha = imageWorker.PercentMatch(messageCapture, CaptchaMessageTrainer);
var serviceUnavailable = imageWorker.PercentMatch(messageCapture, ServiceUnavailableTrainer);
messageCapture.Dispose();
if (captcha > 95)
{
return(InterruptScreen.Captcha);
}
if (serviceUnavailable > 85)
{
return(InterruptScreen.ServiceUnavailable);
}
if (WhatScreenAmIOn() == Screens.Login)
{
return(InterruptScreen.Login);
}
return(InterruptScreen.None);
}
public void performTest1()
{
Bitmap bitmap = new Bitmap(100, 100);
ImageManipulatorType.Name filter = ImageManipulatorType.Name.GRAYSCALE; // TODO: Passenden Wert initialisieren
int threads = 2; // TODO: Passenden Wert initialisieren
ThreadHandler thHandler = new ThreadHandler(threads);
ImageManipulator t = new ImageManipulator(bitmap, filter, thHandler); // TODO: Passenden Wert initialisieren
PrivateObject param0 = new PrivateObject(t); // TODO: Passenden Wert initialisieren
ImageManipulator_Accessor target = new ImageManipulator_Accessor(param0);
BitmapData bmData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
int stride = bmData.Stride;
int bytes = Math.Abs(bmData.Stride) * bmData.Height;
System.IntPtr Scan0 = bmData.Scan0;
target.perform(Scan0, stride);
// Die Funktion stößt nur andere Funktionen ab hier an. Was testen?
bitmap.UnlockBits(bmData);
}
protected void Initialize()
{
//string path = Path.GetDirectoryName(Path.GetDirectoryName(Directory.GetCurrentDirectory()));
string filename = Path.GetFileName(FileUpload1.FileName);
Img = new Bitmap(FileUpload1.PostedFile.InputStream);
IM = new ImageManipulator(Img);
}
public void ResizeImageBytesTest_ThrowArgumentException()
{
string imageFilePath = "target";
IImageManipulator imageManipulator = new ImageManipulator();
Assert.ThrowsException <ArgumentException>(() => imageManipulator.ResizeImageBytes(imageFilePath, imageFilePath));
}
public LedPositionWindow()
{
InitializeComponent();
im = new ImageManipulator();
frame = ScreenCapturer.GetSingleFrame();
this.Width = (int)(frame.Width * windowSizePercent / 100);
this.Height = (int)(frame.Height * windowSizePercent / 100);
pb_main.Image = im.ResizeImage(frame, pb_main.Width, pb_main.Height);
}
public void ToBitmap()
{
foreach (KeyValuePair <string, Bitmap> entry in AllImages)
{
Bitmap bmp = entry.Value;
ImageManipulator im = new ImageManipulator(bmp);
Assert.IsTrue(BmpsAreEqual(im.ToBitmap(), bmp));
}
}
public IHttpActionResult AddDLP([FromBody] DemonstrationDlpInput input)
{
var imageLocation = ImageManipulator.SaveImage(input.CamId, input.DetectedDateTime, input.Img);
var fileInfo = new FileInfo(imageLocation);
var newLocation = ImageManipulator.MoveFileToPerm(fileInfo, input.DetectedDateTime);
var imgUrl = LocationToUrlConverter.ConvertPathToUrl(fileInfo.Name, input.DetectedDateTime);
var result = DetectedPlateHelper.InsertNewDetectedPlate(input.PlateNumber, input.DetectedDateTime, input.CamId, imgUrl, input.Confidence);
return(Json(result));
}
public bool SuccessfulSearch()
{
var imageworker = new ImageManipulator();
var results = CaptureBrowserTransferResults();
var percentMatch = imageworker.PercentMatch(results, ResultWithPlayerTrainer);
results.Dispose();
return(percentMatch >= 79); // TODO we need to fix this. Gold > 90, Icon ~89, Blue ~88, Totw ~78, No results ~76
}
public void ResizeImageBytesTest_SuccessResizeFile()
{
string basePath = AppDomain.CurrentDomain.BaseDirectory;
string sourcePath = basePath + "\\images\\testSourceImage.jpg";
string targetPath = basePath + "\\images\\testTargetImage.jpg";
IImageManipulator imageManipulator = new ImageManipulator();
imageManipulator.ResizeImageBytes(sourcePath, targetPath);
Assert.IsTrue(File.Exists(targetPath));
File.Delete(targetPath);
}
public bool SuccessfulPurchase()
{
var imageworker = new ImageManipulator();
var purchaseCapture = CapturePurchaseResults();
var successScore = imageworker.PercentMatch(purchaseCapture, SuccessfulPurchaseTrainer);
var failureScore = imageworker.PercentMatch(purchaseCapture, FailedPurchaseTrainer);
purchaseCapture.Dispose();
return(successScore > failureScore);
}
public async Task <string> SaveAsync(string base64, bool overrideExisting = false)
{
if (string.IsNullOrEmpty(base64) || string.IsNullOrWhiteSpace(base64) ||
!ImageManipulator.IsImageStream(base64))
{
throw new ArgumentException();
}
var b64Part = GetBase64Part(base64);
var buffer = Convert.FromBase64String(b64Part);
return(await SaveAsync(buffer, overrideExisting));
}
public void performTest()
{
Bitmap bitmap = new Bitmap(10, 10);
ImageManipulatorType.Name filter = ImageManipulatorType.Name.GRAYSCALE; // TODO: Passenden Wert initialisieren
int threads = 2; // TODO: Passenden Wert initialisieren
ThreadHandler thHandler = new ThreadHandler(threads);
ImageManipulator target = new ImageManipulator(bitmap, filter, thHandler); // TODO: Passenden Wert initialisieren
bool expected = true; // TODO: Passenden Wert initialisieren
bool actual = target.perform();
Assert.AreEqual(expected, actual);
}
public void ImageManipulatorConstructorTest()
{
Bitmap bitmap = new Bitmap(10, 10);
ImageManipulatorType.Name filter = ImageManipulatorType.Name.GRAYSCALE; // TODO: Passenden Wert initialisieren
int threads = 2; // TODO: Passenden Wert initialisieren
ThreadHandler thHandler = new ThreadHandler(threads);
ImageManipulator t = new ImageManipulator(bitmap, filter, thHandler); // TODO: Passenden Wert initialisieren
PrivateObject param0 = new PrivateObject(t); // TODO: Passenden Wert initialisieren
ImageManipulator_Accessor target = new ImageManipulator_Accessor(param0);
Assert.IsNotNull(target.bitmap);
Assert.IsNotNull(target.thHandler);
Assert.IsNotNull(target.filter);
}
public async Task <string> SaveAsync(string name, byte[] bytes, bool overrideExisting = false)
{
if (string.IsNullOrEmpty(name) || string.IsNullOrWhiteSpace(name) || bytes == null ||
!ImageManipulator.IsImageStream(bytes))
{
throw new ArgumentException();
}
var buffer = ImageManipulator.ResizeImage(bytes, Options.Width, Options.Height, Options.ImageFormat);
var blobName = Options.Prefix + name + Options.ImageFormat.ToString();
await BlobContainer.SaveAsync(blobName, buffer, overrideExisting);
return(blobName);
}
public async Task <string> SaveAsync(string name, string base64, bool overrideExisting = false)
{
if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(base64) || string.IsNullOrWhiteSpace(base64) ||
!ImageManipulator.IsImageStream(base64))
{
throw new ArgumentException();
}
var b64Part = GetBase64Part(base64);
var resizedB64Img = ImageManipulator.ResizeImage(b64Part, Options.Width, Options.Height, Options.ImageFormat);
var buffer = Convert.FromBase64String(resizedB64Img);
var blobName = await SaveAsync(name, buffer, overrideExisting);
return(blobName);
}
public async Task <string> SaveAsync(byte[] bytes, bool overrideExisting = false)
{
if (bytes == null || !ImageManipulator.IsImageStream(bytes))
{
throw new ArgumentException();
}
var buffer = ImageManipulator.ResizeImage(bytes, Options.Width, Options.Height, Options.ImageFormat);
var name = GenerateName(buffer);
var blobName = string.Format("{0}{1}.{2}", Options.Prefix, name, Options.ImageFormat.ToString());
await BlobContainer.SaveAsync(blobName, buffer, overrideExisting);
return(blobName);
}
public void computeHeightStepsTest()
{
Bitmap bitmap = new Bitmap(10, 10);
ImageManipulatorType.Name filter = ImageManipulatorType.Name.GRAYSCALE; // TODO: Passenden Wert initialisieren
int threads = 2; // TODO: Passenden Wert initialisieren
ThreadHandler thHandler = new ThreadHandler(threads);
ImageManipulator t = new ImageManipulator(bitmap, filter, thHandler); // TODO: Passenden Wert initialisieren
PrivateObject param0 = new PrivateObject(t); // TODO: Passenden Wert initialisieren
ImageManipulator_Accessor target = new ImageManipulator_Accessor(param0);
int height = 10; // TODO: Passenden Wert initialisieren
int expected = 5; // TODO: Passenden Wert initialisieren
int actual;
actual = target.computeHeightSteps(height);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Generates the output file.
/// </summary>
/// <param name="data">The processing data.</param>
/// <returns></returns>
private string GenerateOutputFile(ProcessingModel data)
{
var progressReporter = new Progress <int>();
progressReporter.ProgressChanged += (sender, percent) =>
{
data.Percent = percent;
this.StoreGenerationProgress(data);
};
var serializer = this.Encoder;
var imageManipulator = new ImageManipulator(this.Environment);
var excelManipulator = new ExcelManipulator(serializer, imageManipulator, progressReporter);
var sourceFilePath = HomeController.GetTempInputFilePath(data.RequestId);
var templateFilePath = Path.Combine(this.Environment.WebRootPath, "platobne_predpisy.xltx");
var outputFilePath = HomeController.GetTempOutputFilePath(data.RequestId);
// another request tries to download the same file?
if (System.IO.File.Exists(outputFilePath))
{
// wait for the other thread to complete
while (true)
{
try
{
using (System.IO.File.OpenWrite(outputFilePath))
{
break;
}
}
catch
{
// wait a while
Thread.Sleep(5000);
}
}
return(outputFilePath);
}
// read source data
(string paymentPurpose, var bySquareDocuments) = excelManipulator.ReadPaymentList(sourceFilePath);
// create the output
return(excelManipulator.CreateOutputFile(templateFilePath, outputFilePath, paymentPurpose, bySquareDocuments));
}
private string GenerateName(byte[] bytes, bool randomize = true)
{
if (bytes == null || !ImageManipulator.IsImageStream(bytes))
{
throw new ArgumentException();
}
var b16Str = Md5Hasher.GenerateBase16Hash(bytes);
var seededName = b16Str;
if (randomize)
{
var seed = DateTime.Now.Second * DateTime.Now.Minute;
seededName += seed.ToString("X");
}
return(seededName);
}
public IActionResult Sample()
{
// create object
var bySquareXmlDocuments = this.CreateSampleBySquareXmlDocument(this.AppSettings.ExternalGenerator);
// serialize object
ViewData["XML"] = new BySquareXmlSerializer().SerializeAsXml(bySquareXmlDocuments);
// generate QR code
var qrstring = this.Encoder.Encode(bySquareXmlDocuments.Documents[0]);
// create final image
var image = new ImageManipulator(this.Environment).CreateQrCodeWithLogo(qrstring);
ViewData["IMAGE"] = new ImageManipulator(this.Environment).EncodeImageAsBase64String(image);
// render object
return(View());
}
/// <summary>
/// Draws the <see cref="BackgroundImage"/> property onto <see cref="MobileUserControl"/>
/// </summary>
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
if (BackgroundImage == null)
{
return;
}
var image = BackgroundImage;
if (AutoScaleBackgroundImage && Dpi.IsHiDpi)
{
image = ImageManipulator.Stretch(BackgroundImage, Dpi.ScaleSize(BackgroundImage.Size));
}
var gfx = GraphicsEx.FromGraphics(e.Graphics);
gfx.DrawImage(image, ClientSize, BackgroundDrawMode);
}
