public void Convert_RM2K3BToMVTest()
{
converter = new TilesetConverterVerticalRM2K3(Tileset.R2k_2k3_B, SpriteMode.ALIGN_TOP_LEFT, false);
Bitmap converted = converter.ConvertToMV(BitmapFromResourceStream("Tests.Images.R2k.R2k3_in.png"))[0];
Bitmap R2kOut = BitmapFromResourceStream("Tests.Images.R2k.Converter.R2k3_out_b_success.png");
Assert.IsTrue(ImageEditor.IsEqual(converted, R2kOut));
}
public void Convert_R95ToMVTest()
{
converter = new TilesetConverterVertical(new Maker.R95(), SpriteMode.ALIGN_TOP_LEFT, false);
Bitmap converted = converter.ConvertToMV(BitmapFromResourceStream("Tests.Images.R95.95_in.bmp"))[0];
Bitmap R95out = BitmapFromResourceStream("Tests.Images.R95.Converter.95_out_success.png");
Assert.IsTrue(ImageEditor.IsEqual(converted, R95out));
}
public void Convert_VX12ToMVTest()
{
converter = new TilesetConverterVX(Tileset.VX_Ace_A12, SpriteMode.ALIGN_TOP_LEFT, false);
Bitmap converted = converter.ConvertToMV(BitmapFromResourceStream("Tests.Images.VX.VX_a12_in.png"))[0];
Bitmap VXOut = BitmapFromResourceStream("Tests.Images.VX.Converter.VX_a12_out_success.png");
Assert.IsTrue(ImageEditor.IsEqual(converted, VXOut));
}
public void Convert_XPToMVTest()
{
converter = new TilesetConverterVertical(new Maker.XP_Tile(), SpriteMode.ALIGN_TOP_LEFT, false);
Bitmap converted = converter.ConvertToMV(BitmapFromResourceStream("Tests.Images.XP.XP_in.png"))[0];
Bitmap XPOut = BitmapFromResourceStream("Tests.Images.XP.Converter.XP_out_success.png");
Assert.IsTrue(ImageEditor.IsEqual(converted, XPOut));
}
public void Convert_CustomToMVTest()
{
converter = new TilesetConverterCustom(Tileset.Custom(22), SpriteMode.ALIGN_TOP_LEFT, false);
Bitmap converted = converter.ConvertToMV(BitmapFromResourceStream("Tests.Images.Custom.Custom22px_in.png"))[0];
Bitmap AlphaOut = BitmapFromResourceStream("Tests.Images.Custom.Converter.Custom22px_out_success.png");
Assert.IsTrue(ImageEditor.IsEqual(converted, AlphaOut));
}
private void ImageGrid_CellContentDoubleClick(object sender, DataGridViewCellEventArgs e)
{
String fileName = OSservices.AddSlash(rootDir) + (String)ImageGrid.Rows[e.RowIndex].Cells[2].Value;
ImageEditor ie = new ImageEditor(fileName);
ie.ShowDialog();
ie.Dispose();
ie = null;
}
public override void Undo()
{
if (ImageEditor.CanUndo)
{
ImageEditor.Undo();
}
UndoButton.Enabled = ImageEditor.CanUndo;
RedoButton.Enabled = ImageEditor.CanRedo;
IsDirty = true;
}
public void Should_Resize_Image_When_Called()
{
var width = 233;
var height = 300;
var newImage = ImageEditor.ResizeImage(path, width, height);
Assert.AreEqual(newImage.Width, width);
Assert.AreEqual(newImage.Height, height);
}
protected override void OnDrawMove(DmiEXImage dmiExImage, Point[] p)
{
if (Keyboard.Modifiers.HasFlag(ModifierKeys.Control))
{
ImageEditor.DeSelectPixel(p);
}
else
{
ImageEditor.SelectPixel(p);
}
}
public void Convert_S97ToMVTest()
{
converter = new TilesetConverterVertical(Tileset.S97, SpriteMode.ALIGN_TOP_LEFT, false);
Bitmap[] converted = converter.ConvertToMV(BitmapFromResourceStream("Tests.Images.S97.97_in.bmp"));
Bitmap S97out1 = BitmapFromResourceStream("Tests.Images.S97.Converter.97_out1_success.png");
Bitmap S97out2 = BitmapFromResourceStream("Tests.Images.S97.Converter.97_out2_success.png");
bool isTrue = ImageEditor.IsEqual(converted[0], S97out1) && ImageEditor.IsEqual(converted[1], S97out2);
Assert.IsTrue(isTrue);
}
private void SaveImageFaces(string imgPath, string facesFolder)
{
var faces = DetectFacesOnImage(imgPath);
foreach (var faceRect in faces)
{
var img = PrepareImageForNeuralNetwork(imgPath, faceRect);
var facePath = Path.Combine(facesFolder, "test1111.jpg");
ImageEditor.SaveImage(img, facePath);
}
}
public void Convert_RM2K3ABToMVTest()
{
converter = new TilesetConverterVerticalRM2K3(new Maker.R2k_2k3_AB(), SpriteMode.ALIGN_TOP_LEFT, false);
Bitmap[] converted = converter.ConvertToMV(BitmapFromResourceStream("Tests.Images.R2k.R2k3_in.png"));
Bitmap R2kOut1 = BitmapFromResourceStream("Tests.Images.R2k.Converter.R2k3_out_ab_success_0.png");
Bitmap R2kOut2 = BitmapFromResourceStream("Tests.Images.R2k.Converter.R2k3_out_ab_success_1.png");
bool isTrue = ImageEditor.IsEqual(converted[0], R2kOut1) && ImageEditor.IsEqual(converted[1], R2kOut2);
Assert.IsTrue(isTrue);
}
public async Task <ImageResource> DownloadImageAsync(string url)
{
using (var client = new WebClient())
{
return(await Task.Run(() =>
{
var data = client.DownloadData(url);
return ImageEditor.Resize(url, data);
}));
}
}
private static void ApplyExisting(string source, string previewImage)
{
try {
var cropped = ImageEditor.Proceed(source, new Size(CommonAcConsts.TrackPreviewWidth, CommonAcConsts.TrackPreviewHeight));
using (var t = FileUtils.RecycleOriginal(previewImage)) {
cropped?.SaveTo(t.Filename);
}
} catch (Exception e) {
NonfatalError.Notify(ControlsStrings.AcObject_CannotUpdatePreview, e);
}
}
public void ImageEditor_PaintValue_InvalidArgsValue_Nop(object value)
{
var editor = new ImageEditor();
using (var image = new Bitmap(10, 10))
using (Graphics graphics = Graphics.FromImage(image))
{
var e = new PaintValueEventArgs(null, value, graphics, new Rectangle(1, 2, 3, 4));
editor.PaintValue(e);
}
}
/// <summary>
/// Uploads a file to predefined directory.
/// </summary>
/// <param name="execContext">Execution context</param>
/// <param name="settings">Custom defined settings in conficuration file.</param>
/// <returns>Dictionary of string objects containing the information of the uploaded files.</returns>
private object UploadFiles(IDataLoaderWriteContext execContext, WriteCustomSettings settings)
{
CheckMaxFileSpacePerDashboard(execContext, settings.FileRestrictions);
CreateDirectoryIfSuchDoesNotExist(settings.UploadFolder);
List <Dictionary <string, object> > result = new List <Dictionary <string, object> >();
double height = settings.PreviewHeight ?? 60D;
double width = settings.PreviewWidth ?? 120D;
string fileName;
string previewName;
HtmlEncoder encoder = HtmlEncoder.Default;
foreach (object item in execContext.ProcessingContext.InputModel.Data.Values)
{
if (item is IPostedFile postedFile)
{
fileName = RenameUploadedFileIfNameExists(postedFile.FileName, settings.UploadFolder);
if (postedFile.ContentType.IndexOf("image", StringComparison.InvariantCultureIgnoreCase) > -1 && _ImageValidator.GetValidMimeTypes.Any(s => postedFile.ContentType.IndexOf(s, StringComparison.InvariantCultureIgnoreCase) > -1 && _ImageValidator.ValidateIfStreamIsImage(postedFile.OpenReadStream(), s)))
{
using (IImageEditor imageEditor = new ImageEditor(postedFile))
{
imageEditor.Save(Path.Combine(settings.UploadFolder, fileName));
previewName = GeneratePreviewName(fileName);
imageEditor.Resize(width, height);
imageEditor.Save(Path.Combine(settings.UploadFolder, previewName));
}
}
else
{
using (var stream = new FileStream(Path.Combine(settings.UploadFolder, fileName), FileMode.Create))
{
postedFile.OpenReadStream().CopyTo(stream);
}
}
result.Add(new Dictionary <string, object>()
{
{ NAME, string.IsNullOrEmpty(postedFile.Name) ? postedFile.FileName : encoder.Encode(postedFile.Name) },//user input please escape
{ FILENAME, fileName },
{ CONTENTTYPE, postedFile.ContentType },
{ ORIGINALFILENAME, postedFile.FileName },
{ LENGTH, postedFile.Length }
});
}
}
return(result);
}
public void Should_Rotate_Image_When_Called()
{
var originalWidth = Image.FromFile(path).Width;
var originalHeight = Image.FromFile(path).Height;
var rotatedImage = ImageEditor.RotateImage(path, RotateFlipType.Rotate90FlipNone);
Assert.AreNotEqual(originalWidth, rotatedImage.Width);
Assert.AreNotEqual(originalHeight, rotatedImage.Height);
Assert.AreEqual(originalWidth, rotatedImage.Height);
Assert.AreEqual(originalHeight, rotatedImage.Width);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
ArrayList list = new ArrayList();
if (provider == null)
{
return(value);
}
if (((IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService))) != null)
{
if (this.fileDialog == null)
{
this.fileDialog = new OpenFileDialog();
this.fileDialog.Multiselect = true;
string str = ImageEditor.CreateFilterEntry(this);
for (int i = 0; i < this.GetImageExtenders().Length; i++)
{
ImageEditor o = (ImageEditor)Activator.CreateInstance(this.GetImageExtenders()[i], BindingFlags.CreateInstance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, null, null);
System.Type type = base.GetType();
System.Type type2 = o.GetType();
if ((!type.Equals(type2) && (o != null)) && type.IsInstanceOfType(o))
{
str = str + "|" + ImageEditor.CreateFilterEntry(o);
}
}
this.fileDialog.Filter = str;
}
IntPtr focus = System.Design.UnsafeNativeMethods.GetFocus();
try
{
if (this.fileDialog.ShowDialog() != DialogResult.OK)
{
return(list);
}
foreach (string str2 in this.fileDialog.FileNames)
{
FileStream stream = new FileStream(str2, FileMode.Open, FileAccess.Read, FileShare.Read);
ImageListImage image = this.LoadImageFromStream(stream, str2.EndsWith(".ico"));
image.Name = Path.GetFileName(str2);
list.Add(image);
}
}
finally
{
if (focus != IntPtr.Zero)
{
System.Design.UnsafeNativeMethods.SetFocus(new HandleRef(null, focus));
}
}
}
return(list);
}
private void ShowImage()
{
if (_ImageEditor == null)
{
_ImageEditor = new ImageEditor();
_ImageEditor.Init(this, User);
}
MyObj.Children.Clear();
MyObj.Children.Add(_ImageEditor);
MyUri.Editor = _ImageEditor;
}
public IActionResult ConvertToPng()
{
var body = getImage();
if (body == null)
{
return(StatusCode(404));
}
var result = ImageEditor.ConvertToPng(body);
return(File(result, "image/png", "image.png"));
}
public IActionResult Discolor(bool isSepia)
{
var body = getImage();
if (body == null)
{
return(StatusCode(404));
}
var result = ImageEditor.Discolor(body, isSepia);
putImage(result);
return(Content(Convert.ToBase64String(result)));
}
void DrawBoxes(float[,,] boxes, float[,] scores, float[,] classes, string inputFile, string outputFile, double minScore)
{
_catalog = CatalogUtil.ReadCatalogItems("object-detection.pbtxt");
var x = boxes.GetLength(0);
var y = boxes.GetLength(1);
var z = boxes.GetLength(2);
float ymin = 0, xmin = 0, ymax = 0, xmax = 0;
using (var editor = new ImageEditor(inputFile, outputFile))
{
for (int i = 0; i < x; i++)
{
for (int j = 0; j < y; j++)
{
if (scores[i, j] < minScore)
{
continue;
}
for (int k = 0; k < z; k++)
{
var box = boxes[i, j, k];
switch (k)
{
case 0:
ymin = box;
break;
case 1:
xmin = box;
break;
case 2:
ymax = box;
break;
case 3:
xmax = box;
break;
}
}
int value = Convert.ToInt32(classes[i, j]);
CatalogItem catalogItem = _catalog.FirstOrDefault(item => item.Id == value);
editor.AddBox(xmin, xmax, ymin, ymax, $"{catalogItem.DisplayName} : {(scores[i, j] * 100).ToString("0")}%");
}
}
}
}
public IActionResult Rotate(double angle)
{
var body = getImage();
if (body == null)
{
return(StatusCode(404));
}
byte[] result = ImageEditor.Rotate(body, angle);
putImage(result);
return(Content(Convert.ToBase64String(result)));
}
public IActionResult WriteText(string text, bool isBottom, string font, int fontSize, string color = "white")
{
var body = getImage();
if (body == null)
{
return(StatusCode(404));
}
var result = ImageEditor.WriteText(body, text, isBottom, color, font, fontSize);
putImage(result);
return(Content(Convert.ToBase64String(result)));
}
public IActionResult Blur(int blurSize)
{
var body = getImage();
if (body == null)
{
return(StatusCode(404));
}
var result = ImageEditor.Blur(body, blurSize);
putImage(result);
return(Content(Convert.ToBase64String(result)));
}
public void TransformToBlurred_HappyDays()
{
ImageEditor imageEditor = new ImageEditor();
var test = new Bitmap(3, 3);
for (int x = 0; x < test.Width; x++)
{
for (int y = 0; y < test.Height; y++)
{
if (x == 1 && y == 1)
{
test.SetPixel(x, y, Color.FromArgb(100, 100, 100));
}
else
{
test.SetPixel(x, y, Color.FromArgb(100, 150, 200));
}
}
}
var expected = new Bitmap(3, 3);
for (int x = 0; x < expected.Width; x++)
{
for (int y = 0; y < expected.Height; y++)
{
if (x == 1 && y == 1)
{
expected.SetPixel(x, y, Color.FromArgb(100 * 9 / 9, (150 * 8 + 100) / 9, (200 * 8 + 100) / 9));
}
else if (x != 1 && y != 1)
{
expected.SetPixel(x, y, Color.FromArgb(100 * 4 / 4, (150 * 3 + 100) / 4, (200 * 3 + 100) / 4));
}
else
{
expected.SetPixel(x, y, Color.FromArgb(100 * 6 / 6, (150 * 5 + 100) / 6, (200 * 5 + 100) / 6));
}
}
}
var actual = imageEditor.TransformToBlurred(test);
for (int x = 0; x < actual.Width; x++)
{
for (int y = 0; y < actual.Height; y++)
{
Assert.AreEqual(expected.GetPixel(x, y), actual.GetPixel(x, y));
}
}
}
public IActionResult Crop(string relation, int startX = 0, int startY = 0, int stopX = 0, int stopY = 0)
{
var body = getImage();
if (body == null)
{
return(StatusCode(404));
}
byte[] result = ImageEditor.Crop(body, relation, startX, startY, stopX, stopY);
putImage(result);
return(Content(Convert.ToBase64String(result)));
}
public ImageEditorPage(byte[] img)
{
InitializeComponent();
BindingContext = ViewModel = new ImageEditorViewModel(img);
//https://help.syncfusion.com/xamarin/sfimageeditor/toolbarcustomization
var itemNames = ImageEditor.ToolbarSettings.ToolbarItems.Select(i => i.Name.ToLower()).Except(new[] { "transform" }).ToList();
itemNames.Add("rotate");
if (Device.RuntimePlatform == Device.iOS)
{
itemNames.Add("flip"); //looks like flip doesn't work on iOS after save
}
ImageEditor.SetToolbarItemVisibility(string.Join(",", itemNames), false);
}
public LockScreenImage(string filePath, ScreenResolution screenResolution)
{
this.FilePath = filePath;
var image = Image.FromFile(filePath);
this.Image = ImageEditor.ScaleImage(
image,
screenResolution.Width,
screenResolution.Height);;
this.NotificationArea = new NotificationArea(this.Image.Width, this.Image.Height);
this.NotificationCanvas = new NotificationCanvas(this.NotificationArea.Width, this.NotificationArea.Height);
this.DrawNotificationArea();
}
public void Render_IfImageUrlIsNotNull_WriteOutput()
{
// Arrange
_imageEditor = new ImageEditor();
_privateObject = new PrivateObject(_imageEditor);
HtmlTextWriter htmlTextWriter = Setup("x");
// Act
_privateObject.Invoke("Render", htmlTextWriter);
// Assert
htmlTextWriter.ShouldSatisfyAllConditions
(
() => htmlTextWriter.Indent.ShouldBe(1),
() => htmlTextWriter.NewLine.ShouldBe(null)
);
}
public string Repair_File(string fileName, string fileOut, ImageFileFormat format)
{
ImageEditor repair = new ImageEditor();
bool ret = repair.Edit(fileName, _OnEditPage, fileOut, format, true);
return txtRslt.Text;
}
/// <override></override>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) {
if (context != null && context.Instance != null && provider != null) {
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null) {
ImageEditor imageEditor = null;
try {
if (value is NamedImage && value != null)
imageEditor = new ImageEditor((NamedImage)value);
else imageEditor = new ImageEditor();
if (imageEditor.ShowDialog() == System.Windows.Forms.DialogResult.OK)
value = imageEditor.Result;
} finally {
if (imageEditor != null) imageEditor.Dispose();
imageEditor = null;
}
}
}
return value;
}
public string Repair_Page(string fileName, int page, string fileOut, ImageFileFormat format)
{
string s = "";
ImageEditor repair = new ImageEditor();
repair.Image.Open(fileName, page);
// Demonstates basic
s = s + "File:" + fileName + " Page:" + page.ToString() + Environment.NewLine;
repair.AutoDeskew(); s = s + "AutoDeskew" + Environment.NewLine;
repair.AutoCrop(50, 50, 50, 50); s = s + "AutoCrop (margins 50pix)" + Environment.NewLine;
// Save results
if (fileOut != "")
{
if (File.Exists(fileOut))
{
repair.Image.Append(fileOut, Inlite.ClearImage.EFileFormat.ciEXT);
s = s + "Append:" + fileOut;
}
else
{
repair.Image.SaveAs(fileOut, Inlite.ClearImage.EFileFormat.ciEXT);
s = s + "SaveAs:" + fileOut;
}
}
s = s + Environment.NewLine + "--------------" + Environment.NewLine;
return s;
}
public string Repair_Stream(string fileName, string fileOut, ImageFileFormat format)
{
MemoryStream ms = Utility.FileToStream(fileName);
ImageEditor repair = new ImageEditor();
MemoryStream msOut = repair.Edit(ms, _OnEditPage, format);
if (msOut != null)
Utility.StreamToFile(msOut, fileOut);
return txtRslt.Text;
}
public string Tools_Page(string fileName, int page)
{
string s = "";
ImageEditor tools = new ImageEditor();
tools.Image.Open(fileName, page);
double dSkew = tools.SkewAngle; s = s + string.Format("Skew {0:0.##} deg", dSkew) + Environment.NewLine;
if (tools.BitsPerPixel == 1)
{
ImageObject[] objects = tools.GetObjects();
s = s + string.Format("Object Count: {0}", objects.Length) + Environment.NewLine;
}
return s;
}
public string Tools_Page_WithEvents(string fileName, int page, bool bSaveResults)
{
ImageEditor tools = new ImageEditor();
tools.Image.Open(fileName, page);
// Configure events
tools.ObjectFoundEvent += new ImageEditor.ObjectFoundEventHandler (_OnObjectFound);
tools.GetObjects();
return txtRslt.Text;
}
