public IBitmap Generate(PointF start, PointF end)
{
var b = new System.Drawing.Bitmap(WIDTH, HEIGHT);
var lX = end.X - start.X;
var lY = end.Y - start.Y;
Parallel.ForEach(Enumerable.Range(0, WIDTH), x =>
{
Parallel.ForEach(Enumerable.Range(0, HEIGHT), y =>
{
double real = start.X + (lX * ((double)x / WIDTH));
double imag = start.Y + (lY * ((double)y / HEIGHT));
var iters = InSet(new Complex(real, imag));
var color = 255 - (iters * 255 / MAX_ITER);
lock (BitmapLock)
{
b.SetPixel(x, y, Color.FromArgb(color, color, color));
}
});
});
using MemoryStream memory = new MemoryStream();
b.Save(memory, ImageFormat.Png);
memory.Position = 0;
//AvIrBitmap is our new Avalonia compatible image. You can pass this to your view
Avalonia.Media.Imaging.Bitmap AvIrBitmap = new Avalonia.Media.Imaging.Bitmap(memory);
return(AvIrBitmap);
}
public void AddToDataBase(ResultClassification obj)
{
lock (db)
{
Avalonia.Media.Imaging.Bitmap BImage = new Avalonia.Media.Imaging.Bitmap(obj._PathImage);
Blob ImageBlob = new Blob {
Bytes = ImageToByteArray(BImage)
};
db.Blobs.Add(ImageBlob);
db.SaveChanges();
RecognitionImage elem = new RecognitionImage
{
Class = obj._ClassImage,
Prob = obj.Probability,
ImageBytes = ImageBlob,
Call = 0,
Hash = GetHashFromBytes(ImageToByteArray(BImage))
};
db.Images.Add(elem);
db.SaveChanges();
}
}
public byte[] ImageToByteArray(Avalonia.Media.Imaging.Bitmap image)
{
using (MemoryStream stream = new MemoryStream())
{
image.Save(stream);
return(stream.ToArray());
}
}
public static Avalonia.Media.Imaging.Bitmap ToAvaloniaBitmap(this Bitmap bitmap)
{
var tempFile = Path.GetTempFileName();
bitmap.Save(tempFile);
var result = new Avalonia.Media.Imaging.Bitmap(tempFile);
File.Delete(tempFile);
return(result);
}
public Image LoadImage(Stream stream)
{
var data = Image.FromStream(stream);
using var image = new AMI.Bitmap(stream);
return(new Image
{
Data = data,
Width = (float)image.Size.Width,
Height = (float)image.Size.Height
});
}
void ImageLoad(string path)
{
MagickImage image = new MagickImage(path);
image.Format = MagickFormat.Jpeg;
MemoryStream tmpstream = new MemoryStream();
image.Write(tmpstream);
tmpstream.Position = 0;
Avalonia.Media.Imaging.Bitmap amib = new Avalonia.Media.Imaging.Bitmap(tmpstream);
Image img = this.Get <Image>("ImageView");
img.Source = amib;
}
private Avalonia.Media.Imaging.Bitmap ConvertToAvaloniaImage(System.Drawing.Bitmap image)
{
var stream = new MemoryStream();
image.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
image.Dispose();
stream.Seek(0, SeekOrigin.Begin);
var avaloniaImage = new Avalonia.Media.Imaging.Bitmap(stream);
stream.Dispose();
return(avaloniaImage);
}
/// <summary>
/// データのダウンロード完了後イベントハンドラ
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ClientDownloadDataCompleted(object sender, DownloadDataCompletedEventArgs e)
{
try
{
byte[] bytes = e.Result;
Stream stream = new MemoryStream(bytes);
var image = new Avalonia.Media.Imaging.Bitmap(stream);
var bitmapProperty = (ReactivePropertySlim <Avalonia.Media.Imaging.Bitmap>?)e.UserState;
bitmapProperty !.Value = image;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
}
public override void UpdateGeometry()
{
ScaleThickness = Image.State.Flags.HasFlag(ShapeStateFlags.Thickness);
ScaleSize = Image.State.Flags.HasFlag(ShapeStateFlags.Size);
if (!string.IsNullOrEmpty(Image.Key))
{
ImageCached = BitmapCache.Get(Image.Key) as AMI.Bitmap;
if (ImageCached == null && ImageCache != null)
{
try
{
var bytes = ImageCache.GetImage(Image.Key);
if (bytes != null)
{
using var ms = new System.IO.MemoryStream(bytes);
ImageCached = new AMI.Bitmap(ms);
BitmapCache.Set(Image.Key, ImageCached);
}
}
catch (Exception ex)
{
Debug.WriteLine($"{ex.Message}");
Debug.WriteLine($"{ex.StackTrace}");
}
}
if (ImageCached != null)
{
SourceRect = new A.Rect(0, 0, ImageCached.PixelSize.Width, ImageCached.PixelSize.Height);
}
}
else
{
ImageCached = null;
}
var rect2 = Rect2.FromPoints(Image.TopLeft.X, Image.TopLeft.Y, Image.BottomRight.X, Image.BottomRight.Y, 0, 0);
DestRect = new A.Rect(rect2.X, rect2.Y, rect2.Width, rect2.Height);
Center = DestRect.Center;
base.UpdateTextGeometry();
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value == null)
{
return(null);
}
else
{
using (var memoryStream = new MemoryStream())
{
var bitmap1 = new System.Drawing.Bitmap(value as Image);
//(value as Image)
bitmap1.Save(memoryStream, ImageFormat.Jpeg);
memoryStream.Seek(0, SeekOrigin.Begin);
var bitmap = new Avalonia.Media.Imaging.Bitmap(memoryStream);
return(bitmap);
}
}
}
private async Task GenerateMaze()
{
BusyGeneratingMaze2.OnNext(false);
await Task.Run(() =>
{
var builder = new MazeBuilder()
.SetMazeAlgorithm(this.SelectedMazeGenAlgorithm)
.SetMazeDimensions(MazeWidth, MazeHeight)
.RecordMazeTransformationSteps();
this._Maze = builder.Build();
var image = MazeImageCreator.GetMazeImage(_Maze, 10);
this._MazeImage = ConvertToAvaloniaImage(image);
// this.StepsToDraw = builder.GetMazeTransformationSteps();
Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
BusyGeneratingMaze2.OnNext(true);
}).ConfigureAwait(true);
}
/// <inheritdoc/>
public override void Draw(object dc, ImageShape image, double dx, double dy, object db, object r)
{
var _dc = dc as AM.DrawingContext;
var rect = CreateRect(image.TopLeft, image.BottomRight, dx, dy);
if (image.IsStroked || image.IsFilled)
{
AM.IBrush brush = ToBrush(image.Style.Fill);
AM.Pen pen = ToPen(image.Style, _scaleToPage);
DrawRectangleInternal(
_dc,
brush,
pen,
image.IsStroked,
image.IsFilled,
ref rect);
}
if (_enableImageCache &&
_biCache.ContainsKey(image.Key))
{
try
{
var bi = _biCache[image.Key];
_dc.DrawImage(
bi,
1.0,
new A.Rect(0, 0, bi.PixelWidth, bi.PixelHeight),
new A.Rect(rect.X, rect.Y, rect.Width, rect.Height));
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
else
{
if (State.ImageCache == null || string.IsNullOrEmpty(image.Key))
{
return;
}
try
{
var bytes = State.ImageCache.GetImage(image.Key);
if (bytes != null)
{
using (var ms = new System.IO.MemoryStream(bytes))
{
var bi = new AMI.Bitmap(ms);
if (_enableImageCache)
{
_biCache[image.Key] = bi;
}
_dc.DrawImage(
bi,
1.0,
new A.Rect(0, 0, bi.PixelWidth, bi.PixelHeight),
new A.Rect(rect.X, rect.Y, rect.Width, rect.Height));
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
}
private Task <Bitmap> GetBitmapAsync(string filePath, int size)
{
var resizedFilePath = GetResizedPath(filePath, size);
// return cached version
if (_cache.TryGetValue(resizedFilePath, out var item))
{
var bitmap = (Bitmap)item;
return(Task.FromResult(bitmap));
}
// return resized version from disk
if (File.Exists(resizedFilePath))
{
lock (_locker)
{
if (File.Exists(resizedFilePath))
{
var bitmap = new Bitmap(resizedFilePath);
_cache.Set(resizedFilePath, bitmap, new MemoryCacheEntryOptions
{
Size = 1
});
return(Task.FromResult(bitmap));
}
}
}
// resize and return image
if (File.Exists(filePath))
{
return(Task.Run(() =>
{
lock (_locker)
{
if (File.Exists(filePath) && !File.Exists(resizedFilePath))
{
if (_platform is WindowsPlatform)
{
ResizeWithSystemDrawing(filePath, resizedFilePath, size);
}
else
{
ResizeWithImageSharp(filePath, resizedFilePath, size);
}
}
if (File.Exists(resizedFilePath))
{
var bitmap = new Bitmap(resizedFilePath);
_cache.Set(resizedFilePath, bitmap, new MemoryCacheEntryOptions
{
Size = 1
});
return bitmap;
}
return null;
}
}));
}
return(Task.FromResult <Bitmap>(null));
}
private void ImportImagesMethod(bool bigImage)
{
Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Wait);
Utility.XOffsetBefore = 0;
Utility.YOffsetBefore = 0;
var filewithoutgm1ending = vm.File.FileHeader.Name.Replace(".gm1", "");
if (!bigImage)
{
var files = Directory.GetFiles(vm.UserConfig.WorkFolderPath + "\\" + filewithoutgm1ending + "\\Images", "*.png", SearchOption.TopDirectoryOnly);
//sort because 11 is before 2
files = files.OrderBy(x => x.Length).ThenBy(x => x).ToArray <String>();
int counter = 1;
foreach (var file in files)
{
var filename = Path.GetFileName(file);
if (filename.Equals("Image" + counter + ".png"))
{
Avalonia.Media.Imaging.Bitmap image = new Avalonia.Media.Imaging.Bitmap(file);
vm.TGXImages[counter - 1].Source = image;
vm.TGXImages[counter - 1].MaxWidth = image.PixelSize.Width;
vm.TGXImages[counter - 1].MaxHeight = image.PixelSize.Height;
counter++;
var fileindex = int.Parse(filename.Replace("Image", "").Replace(".png", "")) - 1;
int width = 0, height = 0;
var list = Utility.LoadImage(file, ref width, ref height, vm.File.ImagesTGX[fileindex].AnimatedColor, 1, vm.File.FileHeader.IDataType);
if (list.Count == 0)
{
return;
}
LoadNewDataForGm1File(fileindex, list, width, height);
}
}
}
else
{
int maxwidth = 650;
int fileindex = 0;
int offsety = 0;
int maxheight = 0;
int offsetx = 0;
int actualwidth = 0;
int counter = 0;
if (((GM1FileHeader.DataType)vm.File.FileHeader.IDataType == GM1FileHeader.DataType.TilesObject))
{
foreach (var image in vm.File.TilesImages)
{
int width = image.Width;
int height = image.Height - ((GM1FileHeader.DataType)vm.File.FileHeader.IDataType == GM1FileHeader.DataType.NOCompression ? 7 : 0);
actualwidth += width;
if (maxwidth <= actualwidth)
{
offsety += maxheight;
actualwidth = width;
maxheight = 0;
offsetx = 0;
}
if (maxheight < height)
{
maxheight = height;
}
var list = Utility.LoadImage(vm.UserConfig.WorkFolderPath + "\\" + filewithoutgm1ending + "\\BigImage\\" + filewithoutgm1ending + ".png", ref width, ref height, vm.File.ImagesTGX[fileindex].AnimatedColor, 1, vm.File.FileHeader.IDataType, offsetx, offsety);
if (list.Count == 0)
{
continue;
}
width = image.Width;
height = image.Height;
LoadNewDataForGm1File(fileindex, list, width, height);
fileindex++;
offsetx += width;
Avalonia.Media.Imaging.Bitmap newimage = Utility.LoadImageAsBitmap(vm.UserConfig.WorkFolderPath + "\\" + filewithoutgm1ending + "\\BigImage\\" + filewithoutgm1ending + ".png", ref width, ref height, offsetx, offsety);
vm.TGXImages[counter].Source = newimage;
vm.TGXImages[counter].MaxWidth = newimage.PixelSize.Width;
vm.TGXImages[counter].MaxHeight = newimage.PixelSize.Height;
counter++;
}
}
else
{
foreach (var image in vm.File.ImagesTGX)
{
int width = image.Width;
int height = image.Height - ((GM1FileHeader.DataType)vm.File.FileHeader.IDataType == GM1FileHeader.DataType.NOCompression ? 7 : 0);
actualwidth += width;
if (maxwidth <= actualwidth)
{
offsety += maxheight;
actualwidth = width;
maxheight = 0;
offsetx = 0;
}
if (maxheight < height)
{
maxheight = height;
}
int oldOffsetx = offsetx;
int oldOffsety = offsety;
var list = Utility.LoadImage(vm.UserConfig.WorkFolderPath + "\\" + filewithoutgm1ending + "\\BigImage\\" + filewithoutgm1ending + ".png", ref width, ref height, vm.File.ImagesTGX[fileindex].AnimatedColor, 1, vm.File.FileHeader.IDataType, offsetx, offsety);
if (list.Count == 0)
{
continue;
}
width = image.Width;
height = image.Height - ((GM1FileHeader.DataType)vm.File.FileHeader.IDataType == GM1FileHeader.DataType.NOCompression ? 7 : 0);
LoadNewDataForGm1File(fileindex, list, width, height);
fileindex++;
offsetx += width;
Avalonia.Media.Imaging.Bitmap newimage = Utility.LoadImageAsBitmap(vm.UserConfig.WorkFolderPath + "\\" + filewithoutgm1ending + "\\BigImage\\" + filewithoutgm1ending + ".png", ref width, ref height, oldOffsetx, oldOffsety);
vm.TGXImages[counter].Source = newimage;
vm.TGXImages[counter].MaxWidth = newimage.PixelSize.Width;
vm.TGXImages[counter].MaxHeight = newimage.PixelSize.Height;
counter++;
}
}
}
if ((GM1FileHeader.DataType)vm.File.FileHeader.IDataType == GM1FileHeader.DataType.TilesObject)
{
vm.File.SetNewTileList();
}
if (vm.File.ImagesTGX.Count > 0)
{
vm.File.ImagesTGX[0].SizeinByteArray = (uint)vm.File.ImagesTGX[0].ImgFileAsBytearray.Length;
}
uint zaehler = 0;
for (int i = 1; i < vm.File.ImagesTGX.Count; i++)
{
zaehler += vm.File.ImagesTGX[i - 1].SizeinByteArray;
vm.File.ImagesTGX[i].OffsetinByteArray = zaehler;
vm.File.ImagesTGX[i].SizeinByteArray = (uint)vm.File.ImagesTGX[i].ImgFileAsBytearray.Length;
}
//datasize neu setzten
uint newDataSize = vm.File.ImagesTGX[vm.File.ImagesTGX.Count - 1].OffsetinByteArray + vm.File.ImagesTGX[vm.File.ImagesTGX.Count - 1].SizeinByteArray;;
vm.File.FileHeader.IDataSize = newDataSize;
Cursor = new Avalonia.Input.Cursor(Avalonia.Input.StandardCursorType.Arrow);
}
public static Bitmap ToSystemBitmap(this Avalonia.Media.Imaging.Bitmap bitmap)
{
using var memoryStream = new MemoryStream();
bitmap.Save(memoryStream);
return(new Bitmap(memoryStream));
}
public ImageTests()
: base(@"Controls\Image")
{
_bitmap = new Bitmap(Path.Combine(OutputPath, "test.png"));
}
/// <inheritdoc/>
public override void Draw(object dc, XImage image, double dx, double dy, ImmutableArray<XProperty> db, XRecord r)
{
var _dc = dc as AM.DrawingContext;
var rect = CreateRect(image.TopLeft, image.BottomRight, dx, dy);
if (image.IsStroked || image.IsFilled)
{
AM.IBrush brush = ToBrush(image.Style.Fill);
AM.Pen pen = ToPen(image.Style, _scaleToPage);
DrawRectangleInternal(
_dc,
brush,
pen,
image.IsStroked,
image.IsFilled,
ref rect);
}
if (_enableImageCache
&& _biCache.ContainsKey(image.Key))
{
try
{
var bi = _biCache[image.Key];
_dc.DrawImage(
bi,
1.0,
new A.Rect(0, 0, bi.PixelWidth, bi.PixelHeight),
new A.Rect(rect.X, rect.Y, rect.Width, rect.Height));
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
else
{
if (State.ImageCache == null || string.IsNullOrEmpty(image.Key))
return;
try
{
var bytes = State.ImageCache.GetImage(image.Key);
if (bytes != null)
{
using (var ms = new System.IO.MemoryStream(bytes))
{
var bi = new AMI.Bitmap(ms);
if (_enableImageCache)
_biCache[image.Key] = bi;
_dc.DrawImage(
bi,
1.0,
new A.Rect(0, 0, bi.PixelWidth, bi.PixelHeight),
new A.Rect(rect.X, rect.Y, rect.Width, rect.Height));
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
}
/// <summary>
/// Init.
/// </summary>
public ImageAdapter(Bitmap image)
{
_image = image;
}
