// Returns UploadResult on success, Exception on failure public async Task <object> Save(IBitmapImage image, ImageFormats format) { var progressItem = new ImageUploadNotification(); _systemTray.ShowNotification(progressItem); try { var uploadResult = await _imgUploader.Upload(image, format, progressItemProgress => progressItem.Progress = progressItemProgress); var link = uploadResult.Url; _recentList.Add(new UploadRecentItem(link, uploadResult.DeleteLink, _imgUploader)); progressItem.RaiseFinished(link); return(uploadResult); } catch (Exception e) { progressItem.RaiseFailed(); return(e); } }
public void SetImage(IBitmapImage Bmp) { using var pngStream = new MemoryStream(); Bmp.Save(pngStream, ImageFormats.Png); var pngClipboardData = new DataObject("PNG", pngStream); using var whiteS = new Bitmap(Bmp.Width, Bmp.Height, PixelFormat.Format24bppRgb); Image drawingImg; if (Bmp is DrawingImage drawingImage) { drawingImg = drawingImage.Image; } else { drawingImg = Image.FromStream(pngStream); } using (var graphics = Graphics.FromImage(whiteS)) { graphics.Clear(Color.White); graphics.DrawImage(drawingImg, 0, 0, Bmp.Width, Bmp.Height); } // Add fallback for applications that don't support PNG from clipboard (eg. Photoshop or Paint) pngClipboardData.SetData(DataFormats.Bitmap, whiteS); Clipboard.Clear(); Clipboard.SetDataObject(pngClipboardData, true); }
// Deprecated in v 2.3 with no error static public Bitmap Rotate(Bitmap bitmap, float angle) { if (bitmap == null) { throw new ArgumentNullException(); } if (angle < 0) { angle += 360; } if (angle != 0 && angle != 90 && angle != 180 && angle != 270) { throw new ArgumentException("Only -90, 0, 90, 180 or 270 degrees rotation is supported", "angle"); } IBitmapImage imageBitmap = BitmapToIImageBitmap(bitmap); try { return(Rotate(imageBitmap, angle)); } finally { Marshal.FinalReleaseComObject(imageBitmap); } }
public async Task <UploadResult> Upload(IBitmapImage Image, ImageFormats Format, Action <int> Progress) { using var w = new WebClient { Proxy = _proxySettings.GetWebProxy() }; if (Progress != null) { w.UploadProgressChanged += (S, E) => Progress(E.ProgressPercentage); } w.Headers.Add("Authorization", await GetAuthorizationHeader()); NameValueCollection values; using (var ms = new MemoryStream()) { Image.Save(ms, Format); values = new NameValueCollection { { "image", Convert.ToBase64String(ms.ToArray()) } }; } var uploadResponse = await UploadValuesAsync <ImgurUploadResponse>(w, "https://api.imgur.com/3/upload.json", values); if (!uploadResponse.Success) { throw new Exception("Response indicates Failure"); } return(new UploadResult { Url = uploadResponse.Data.Link, DeleteLink = $"https://api.imgur.com/3/image/{uploadResponse.Data.DeleteHash}" }); }
public void DrawImage(IBitmapImage Image, Rectangle?Region, int Opacity = 100) { if (!(Image is DrawingImage drawingImage)) { return; } var img = drawingImage.Image; var region = Region ?? new Rectangle(Point.Empty, img.Size); if (Opacity < 100) { var colormatrix = new ColorMatrix { Matrix33 = Opacity / 100.0f }; var imgAttribute = new ImageAttributes(); imgAttribute.SetColorMatrix(colormatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap); _graphics.DrawImage(img, region, 0, 0, img.Width, img.Height, GraphicsUnit.Pixel, imgAttribute); } else { _graphics.DrawImage(img, region); } }
public CollectionService( ISqlService sqlService, ISqlService bgSqlService, IAppSettingsHelper appSettingsHelper, IDispatcherHelper dispatcher, IBitmapFactory bitmapFactory, IBitmapImage missingArtwork, string localFilePrefix, string artworkFilePath, string artistArtworkFilePath) { _bgSqlService = bgSqlService; _sqlService = sqlService; _dispatcher = dispatcher; _appSettingsHelper = appSettingsHelper; _bitmapFactory = bitmapFactory; _missingArtwork = missingArtwork; _localFilePrefix = localFilePrefix; _artworkFilePath = artworkFilePath; _artistArtworkFilePath = artistArtworkFilePath; Songs = new OptimizedObservableCollection <Song>(); Artists = new OptimizedObservableCollection <Artist>(); Albums = new OptimizedObservableCollection <Album>(); Playlists = new OptimizedObservableCollection <Playlist>(); PlaybackQueue = new OptimizedObservableCollection <QueueSong>(); ShufflePlaybackQueue = new OptimizedObservableCollection <QueueSong>(); }
public CollectionService( ISqlService sqlService, ISqlService bgSqlService, IAppSettingsHelper appSettingsHelper, IDispatcherHelper dispatcher, IBitmapFactory bitmapFactory, IBitmapImage missingArtwork, string localFilePrefix, string artworkFilePath, string artistArtworkFilePath) { _bgSqlService = bgSqlService; _sqlService = sqlService; _dispatcher = dispatcher; _appSettingsHelper = appSettingsHelper; _bitmapFactory = bitmapFactory; _missingArtwork = missingArtwork; _localFilePrefix = localFilePrefix; _artworkFilePath = artworkFilePath; _artistArtworkFilePath = artistArtworkFilePath; Songs = new OptimizedObservableCollection<Song>(); Artists = new OptimizedObservableCollection<Artist>(); Albums = new OptimizedObservableCollection<Album>(); Playlists = new OptimizedObservableCollection<Playlist>(); PlaybackQueue = new OptimizedObservableCollection<QueueSong>(); ShufflePlaybackQueue = new OptimizedObservableCollection<QueueSong>(); }
public IBitmapImage ScreenShotWindow(IWindow Window) { _systemTray.HideNotification(); if (Window.Handle == _platformServices.DesktopWindow.Handle) { return(ScreenShot.Capture(_settings.IncludeCursor)); } try { IBitmapImage bmp = null; if (_settings.ScreenShots.WindowShotTransparent) { bmp = ScreenShot.CaptureTransparent(Window, _settings.IncludeCursor); } // Capture without Transparency return(bmp ?? ScreenShot.Capture(Window.Rectangle, _settings.IncludeCursor)); } catch { return(null); } }
public Task Save(IBitmapImage Image, ImageFormats Format, string FileName) { try { var extension = Format.ToString().ToLower(); var fileName = _settings.GetFileName(extension, FileName); Image.Save(fileName, Format); _recentList.Add(new FileRecentItem(fileName, RecentFileType.Image)); // Copy path to clipboard only when clipboard writer is off if (_settings.CopyOutPathToClipboard && !ServiceProvider.Get <ClipboardWriter>().Active) { fileName.WriteToClipboard(); } _systemTray.ShowScreenShotNotification(fileName); } catch (Exception e) { _messageProvider.ShowException(e, _loc.NotSaved); } return(Task.CompletedTask); }
protected void Draw(IEditableFrame Editor, IBitmapImage Image, PointF Position, SizeF?Size, int Opacity) { if (Image == null) { return; } var targetSize = Size ?? new Size(Image.Width, Image.Height); try { //var point = GetPosition(new Size((int)Editor.Width, (int)Editor.Height), targetSize); var destRect = new RectangleF(Position, targetSize); Editor.DrawImage(Image, destRect, Opacity); } catch { } finally { if (_disposeImages) { Image.Dispose(); } } }
/// <summary> /// Rotate and/or flip bitmap /// </summary> /// <param name="bitmap">Image</param> /// <param name="type">Operation</param> /// <returns>Modified bitmap</returns> static public Bitmap RotateFlip(Bitmap bitmap, RotationAngle angle, FlipAxis axis) { if (bitmap == null) { throw new ArgumentNullException(); } IBitmapImage image = BitmapToIImageBitmap(bitmap); try { IBitmapImage imageBitmap = BitmapToIImageBitmap(bitmap); IBasicBitmapOps ops = (IBasicBitmapOps)imageBitmap; if (angle != 0) { ops.Rotate((float)angle, InterpolationHint.InterpolationHintDefault, out imageBitmap); Marshal.FinalReleaseComObject(ops); ops = (IBasicBitmapOps)imageBitmap; } if (axis != FlipAxis.None) { ops.Flip((axis & FlipAxis.X) == FlipAxis.X, (axis & FlipAxis.Y) == FlipAxis.Y, out imageBitmap); Marshal.FinalReleaseComObject(ops); ops = (IBasicBitmapOps)imageBitmap; } return(IBitmapImageToBitmap(imageBitmap)); } finally { Marshal.FinalReleaseComObject(image); } }
public async Task Save(IBitmapImage image, ImageFormats format, string fileName) { var response = await Save(image, format); switch (response) { case UploadResult uploadResult: var link = uploadResult.Url; // Copy path to clipboard only when clipboard writer is off if (_settings.CopyOutPathToClipboard && !ServiceProvider.Get <ClipboardWriter>().Active) { link.WriteToClipboard(); } break; case Exception e: if (!_diskWriter.Active) { ServiceProvider.Get <IMainWindow>().IsVisible = true; var yes = _messageProvider.ShowYesNo( $"{e.Message}\n\nDo you want to Save to Disk?", _loc.ImageUploadFailed); if (yes) { await _diskWriter.Save(image, format, fileName); } } break; } }
public Task Save(IBitmapImage image, ImageFormats format, string fileName) { _clipboard.SetImage(image); _systemTray.ShowNotification(new TextNotification(_loc.ImgSavedClipboard)); return(Task.CompletedTask); }
public Task Save(IBitmapImage Image, ImageFormats Format, string FileName) { _clipboard.SetImage(Image); _systemTray.ShowNotification(new TextNotification("图片已复制到剪贴板")); return(Task.CompletedTask); }
public static bool SetBitmapPalette(IBitmapImage bitmap, ColorPalette palette) { if (bitmap == null) { throw new ArgumentNullException(); } return(bitmap.SetPalette(palette.ConvertToMemory()) == 0); }
/// <summary> /// Create a bitmap image from an IImage object /// </summary> /// <param name="image"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="pixelFormat"></param> /// <param name="hints"></param> /// <param name="bitmap"></param> /// <returns></returns> public virtual extern int CreateBitmapFromImage( IImage image, uint width, uint height, PixelFormat pixelFormat, InterpolationHint hints, out IBitmapImage bitmap );
public Task Save(IBitmapImage Image, ImageFormats Format, string FileName) { if (!File.Exists(FileName)) { Image.Save(FileName, Format); } var winserv = ServiceProvider.Get <IMainWindow>(); winserv.EditImage(FileName); return(Task.CompletedTask); }
public IBitmapImage Capture(IBitmapLoader BitmapLoader) { if (_syncContext == null) { return(_captureWebcam.GetFrame(BitmapLoader)); } IBitmapImage image = null; _syncContext.Run(() => image = _captureWebcam.GetFrame(BitmapLoader)); return(image); }
public void DrawImage(IBitmapImage Image, RectangleF?Region, int Opacity = 100) { if (Image is Direct2DImage direct2DImage) { var bmp = direct2DImage.Bitmap; var rect = Region ?? new RectangleF(0, 0, bmp.Size.Width, bmp.Size.Height); var rawRect = new RawRectangleF(rect.Left, rect.Top, rect.Right, rect.Bottom); _editorSession.RenderTarget.DrawBitmap(bmp, rawRect, Opacity, BitmapInterpolationMode.Linear); } }
private static Bitmap Rotate(IBitmapImage image, float angle) { IBitmapImage imageBitmap; Bitmap bmRet; IBasicBitmapOps ops = (IBasicBitmapOps)image; ops.Rotate(angle, InterpolationHint.InterpolationHintDefault, out imageBitmap); try { bmRet = IBitmapImageToBitmap(imageBitmap); } finally { Marshal.FinalReleaseComObject(imageBitmap); } return(bmRet); }
public Task Save(IBitmapImage image, ImageFormats format, string fileName) { using (var stream = new MemoryStream()) { image.Save(stream, ImageFormats.Png); var decoder = new PngBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad); var win = new ImageEditorWindow(); win.Open(decoder.Frames[0]); win.Show(); } return(Task.CompletedTask); }
/// <summary> /// Flips image around X and/or Y axes /// </summary> /// <param name="bitmap">Image</param> /// <param name="axis">Axis or axes to flip on</param> private static Bitmap Flip(IBitmapImage image, FlipAxis axis) { Bitmap bmRet; IBitmapImage imageBitmap; IBasicBitmapOps ops = (IBasicBitmapOps)image; ops.Flip((axis & FlipAxis.X) == FlipAxis.X, (axis & FlipAxis.Y) == FlipAxis.Y, out imageBitmap); try { bmRet = IBitmapImageToBitmap(imageBitmap); } finally { Marshal.FinalReleaseComObject(imageBitmap); } return(bmRet); }
public async Task SaveScreenShot(IBitmapImage Bmp, string FileName = null) { _audioPlayer.Play(SoundKind.Shot); if (Bmp != null) { var allTasks = AvailableImageWriters .Where(M => M.Active) .Select(M => M.Save(Bmp, _settings.ScreenShots.ImageFormat, FileName)); await Task.WhenAll(allTasks).ContinueWith(T => Bmp.Dispose()); } else { _systemTray.ShowNotification(new TextNotification(_loc.ImgEmpty)); } }
/// <summary> /// Flips image around X and/or Y axes /// </summary> /// <param name="bitmap">Image</param> /// <param name="axis">Axis or axes to flip on</param> static public Bitmap Flip(Bitmap bitmap, FlipAxis axis) { if (bitmap == null) { throw new ArgumentNullException(); } IBitmapImage image = BitmapToIImageBitmap(bitmap); try { return(Flip(image, axis)); } finally { Marshal.FinalReleaseComObject(image); } }
/// <summary> /// Rotates image by specified amount of degrees /// </summary> /// <param name="bitmap">Image</param> /// <param name="angle">Amount of degrees to rotate image by. Must be 90, 180, or 270</param> /// <returns>Rotated image</returns> static public Bitmap Rotate(Bitmap bitmap, RotationAngle angle) { if (bitmap == null) { throw new ArgumentNullException(); } IBitmapImage imageBitmap = BitmapToIImageBitmap(bitmap); try { return(Rotate(imageBitmap, (float)angle)); } finally { Marshal.FinalReleaseComObject(imageBitmap); } }
public static string RenderTemplate(string imagePath) { Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); Pulse.Extensions.RenderOptions ro = new Pulse.Extensions.RenderOptions(); ro.Height = 300; ro.Width = 300; myImage = PulseEmbComExtensions.Render(myDesign, ro); myImage.Save(imagePath, ImageTypes.itAuto); stopWatch.Stop(); TimeSpan ts = stopWatch.Elapsed; string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); return(elapsedTime); }
public static ColorPalette GetBitmapPalette(IBitmapImage bitmap) { if (bitmap == null) { throw new ArgumentNullException(); } IntPtr pPalette; if (bitmap.GetPalette(out pPalette) != 0) { return(null); } ColorPalette palette = new ColorPalette(); palette.ConvertFromMemory(pPalette); Marshal.FreeCoTaskMem(pPalette); return(palette); }
public static Bitmap IBitmapImageToBitmap(IBitmapImage imageBitmap) { if (imageBitmap == null) throw new ArgumentNullException(); Size size; imageBitmap.GetSize(out size); Rectangle rect = new Rectangle(0, 0, size.Width, size.Height); BitmapData lockedBitmapData = new BitmapData(); imageBitmap.LockBits(ref rect, 0U, PixelFormatID.PixelFormat16bppRGB565, out lockedBitmapData); Bitmap bitmap = new Bitmap((int)lockedBitmapData.Width, (int)lockedBitmapData.Height, PixelFormat.Format16bppRgb565); System.Drawing.Imaging.BitmapData bitmapdata = bitmap.LockBits( new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.WriteOnly, PixelFormat.Format16bppRgb565); ImageHelpers.CopyMemory(bitmapdata.Scan0, lockedBitmapData.Scan0, (int)(lockedBitmapData.Height * lockedBitmapData.Stride)); imageBitmap.UnlockBits(ref lockedBitmapData); bitmap.UnlockBits(bitmapdata); return bitmap; }
private void LoadImage(ImageChangedArgs imageArgs) { try { //Set the thumbnail IBitmapImage ibi = ImageUtils.CreateThumbnail(imageArgs.Stream, this.pbThumbnail.Size); Bitmap bmpThumb = ImageUtils.IBitmapImageToBitmap(ibi); this.pbThumbnail.Image = bmpThumb; //Set the image ibi = ImageUtils.CreateThumbnail(imageArgs.Stream, imageArgs.Image.Size); bmpThumb = ImageUtils.IBitmapImageToBitmap(ibi); this.imageViewer1.Image = bmpThumb; } catch { this.pbThumbnail.Image = null; } }
static public IBitmapImage CreateThumbnail(Stream stream, Size size) { if (stream == null) { throw new ArgumentNullException(); } ImagingFactory factory = new ImagingFactoryClass(); IImage image, imageThumb; factory.CreateImageFromStream(new StreamOnFile(stream), out image); image.GetThumbnail((uint)size.Width, (uint)size.Height, out imageThumb); IBitmapImage imageBitmap = null; ImageInfo ii; image.GetImageInfo(out ii); factory.CreateBitmapFromImage(image, (uint)size.Width, (uint)size.Height, ii.PixelFormat, InterpolationHint.InterpolationHintDefault, out imageBitmap); return(imageBitmap); }
public static async Task UploadImage(this IBitmapImage bitmap) { var uploadWriter = ServiceProvider.Get <ImageUploadWriter>(); var settings = ServiceProvider.Get <Settings.Settings>(); var response = await uploadWriter.Save(bitmap, settings.ScreenShots.ImageFormat); switch (response) { case Exception ex: var loc = ServiceProvider.Get <LanguageManager>(); ServiceProvider.MessageProvider.ShowException(ex, loc.ImageUploadFailed); break; case UploadResult uploadResult: uploadResult.Url.WriteToClipboard(); break; } }
static public IBitmapImage CreateGrayScaleImage(Stream stream) { ImagingFactory factory = new ImagingFactoryClass(); IImage image; factory.CreateImageFromStream(new StreamOnFile(stream), out image); ImageInfo ii; image.GetImageInfo(out ii); image.SetImageFlags((ImageFlags)((int)ii.Flags & (int)ImageFlags.ImageFlagsColorSpaceGRAY)); IBitmapImage imageBitmap = null; try { factory.CreateBitmapFromImage(image, (uint)ii.Width, (uint)ii.Height, ii.PixelFormat, InterpolationHint.InterpolationHintDefault, out imageBitmap); } catch { } return(imageBitmap); }
public uint CreateBitmapFromImage(IImage image, uint width, uint height, PixelFormatID pixelFormat, InterpolationHint hints, out IBitmapImage bitmap) { throw new NotImplementedException(); }
public uint CreateNewBitmap(uint width, uint height, PixelFormatID pixelFormat, out IBitmapImage bitmap) { throw new NotImplementedException(); }