public void CreateBitmap()
{
int width = 100;
int height = 100;
int dpi = 96;
Tracing.Log(">> CreateBitmap");
var thread = new Thread(new ThreadStart(() =>
{
Tracing.Log(">> CreateBitmap - Thread start; creating drawing visual");
//Dispatcher.Invoke(new Action(() => {
_drawingVisual = new DrawingVisual();
_drawingContext = _drawingVisual.RenderOpen();
//}));
Tracing.Log(">> CreateBitmap - Drawing to context");
_drawingContext.DrawRectangle(new SolidColorBrush(Colors.HotPink), new Pen(), new Rect(0, 0, 50, 50));
_drawingContext.DrawRectangle(new SolidColorBrush(Colors.Blue), new Pen(), new Rect(50, 0, 50, 50));
_drawingContext.DrawRectangle(new SolidColorBrush(Colors.Orange), new Pen(), new Rect(0, 50, 50, 50));
_drawingContext.DrawRectangle(new SolidColorBrush(Colors.DarkRed), new Pen(), new Rect(50, 50, 50, 50));
_drawingContext.Close();
Tracing.Log(">> CreateBitmap - Finished drawing; creating render target bitmap");
_bitmap = new RenderTargetBitmap(width, height, dpi, dpi, PixelFormats.Default);
_bitmap.Render(_drawingVisual);
Tracing.Log(">> CreateBitmap - Finished work");
_bitmap.Freeze();
}));
//thread.IsBackground = true;
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
}
private void Create3DViewPort()
{
var hvp3d = new HelixViewport3D();
Viewport3D vp3d = new Viewport3D();
var lights = new DefaultLights();
var tp = new Teapot();
hvp3d.Children.Add(lights);
hvp3d.Children.Add(tp);
vp3d = hvp3d.Viewport;
tata.Children.Add(vp3d); // comenter ca pour test
/* MEGA TEST DE L'ESPACE SUBSAHARIEN */
RenderTargetBitmap bmp = new RenderTargetBitmap(800, 800, 96, 96, PixelFormats.Pbgra32);
var rect = new Rect(0, 0, 800, 800);
vp3d.Measure(new Size(800, 800));
vp3d.Arrange(rect);
vp3d.InvalidateVisual();
bmp.Render(vp3d);
PngBitmapEncoder png = new PngBitmapEncoder();
png.Frames.Add(BitmapFrame.Create(bmp));
String filepath = "C:\\Users\\Remi\\Desktop\\canardmasque.png";
using (Stream stm = File.Create(filepath))
{
png.Save(stm);
}
}
private void ButtonSave_Click(object sender, RoutedEventArgs e)
{
var rect = new Rect { Width = 512, Height = 384 };
var dv = new DrawingVisual();
var dc = dv.RenderOpen();
dc.PushTransform(new TranslateTransform(-rect.X, -rect.Y));
dc.DrawRectangle(InkCanvasMain.Background, null, rect);
InkCanvasMain.Strokes.Draw(dc);
dc.Close();
var rtb = new RenderTargetBitmap((int)rect.Width, (int)rect.Height, 96, 96, PixelFormats.Default);
rtb.Render(dv);
var enc = new PngBitmapEncoder();
enc.Frames.Add(BitmapFrame.Create(rtb));
var fn = TextBoxFileName.Text;
if (!fn.EndsWith(".png", StringComparison.OrdinalIgnoreCase)) fn += ".png";
using (Stream s = File.Create(TegakiImageFolder + "/" + fn))
{
enc.Save(s);
}
((TegakiWindowViewModel)DataContext).AddToMediaList(System.IO.Path.GetFullPath(TegakiImageFolder + "/" + fn));
Close();
}
private double[] getFeatures()
{
rtb = new RenderTargetBitmap((int)InkCanvas1.ActualWidth, (int)InkCanvas1.ActualHeight,
96d, 96d, PixelFormats.Default);
rtb.Render(InkCanvas1);
//save the ink to a memory stream
BmpBitmapEncoder encoder = new BmpBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(rtb));
byte[] bitmapBytes;
Bitmap bmp;
using (MemoryStream ms = new MemoryStream())
{
encoder.Save(ms);
ms.Position = 0;
bitmapBytes = ms.ToArray();
ms.Seek(0, SeekOrigin.Begin);
bmp = new Bitmap(ms);
}
bmp = resize.Apply(bmp);
double[] features = ToFeatures(bmp);
return features;
}
public static Image CaptureImage(this FrameworkElement me, bool ensureSize = false)
{
//var width = ContentPanel.ActualWidth == 0 ? 1 : (int)ContentPanel.ActualWidth;
//var height = ContentPanel.ActualHeight == 0 ? 1 : (int)ContentPanel.ActualHeight;
var width = Convert.ToInt32(me.ActualWidth);
width = width == 0 ? 1 : width;
var height = Convert.ToInt32(me.ActualHeight);
height = height == 0 ? 1 : height;
// TODO: Multiplikation der DPI mit der aktuellen PresentationSource
var bmp = new RenderTargetBitmap(
width, height,
96, 96,
PixelFormats.Default);
bmp.Render(me);
var img = new Image
{
Source = bmp,
Stretch = Stretch.None,
Width = width - (ensureSize ? 1 : 0),
Height = height - (ensureSize ? 1 : 0)
};
//img.Measure(new Size(width, height));
//var imageSize = img.DesiredSize;
//img.Arrange(
// new Rect(new Point(0, 0), imageSize));
return img;
}
public static byte[] ExportToPng(this FrameworkElement surface)
{
var transform = surface.LayoutTransform;
surface.LayoutTransform = null;
var size = new Size(surface.ActualWidth, surface.ActualHeight);
surface.Measure(size);
surface.Arrange(new Rect(size));
var renderBitmap = new RenderTargetBitmap((int)size.Width, (int)size.Height, 96d, 96d, PixelFormats.Pbgra32);
renderBitmap.Render(surface);
try
{
using (var outStream = new MemoryStream())
{
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
encoder.Save(outStream);
return outStream.ToArray();
}
}
finally
{
surface.LayoutTransform = transform;
}
}
///
/// Gets a JPG "screenshot" of the current UIElement
///
/// UIElement to screenshot
/// Scale to render the screenshot
/// JPG Quality
/// Byte array of JPG data
public byte[] GetJpgImage(double scale, int quality, int dpi)
{
double actualHeight = this.RootVisual.RenderSize.Height;
double actualWidth = this.RootVisual.RenderSize.Width;
double renderHeight = actualHeight * scale;
double renderWidth = actualWidth * scale;
RenderTargetBitmap renderTarget = new RenderTargetBitmap((int)renderWidth, (int)renderHeight, dpi, dpi, PixelFormats.Pbgra32);
VisualBrush sourceBrush = new VisualBrush(this.RootVisual);
DrawingVisual drawingVisual = new DrawingVisual();
DrawingContext drawingContext = drawingVisual.RenderOpen();
using (drawingContext)
{
drawingContext.PushTransform(new ScaleTransform(scale, scale));
drawingContext.DrawRectangle(sourceBrush, null, new Rect(new Point(0, 0), new Point(actualWidth, actualHeight)));
}
renderTarget.Render(drawingVisual);
JpegBitmapEncoder jpgEncoder = new JpegBitmapEncoder();
jpgEncoder.QualityLevel = quality;
jpgEncoder.Frames.Add(BitmapFrame.Create(renderTarget));
Byte[] _imageArray;
using (MemoryStream outputStream = new MemoryStream())
{
jpgEncoder.Save(outputStream);
_imageArray = outputStream.ToArray();
}
return _imageArray;
}
public void SaveToPng( Canvas surface, string file )
{
// Save current canvas transform
var transform = surface.LayoutTransform;
// reset current transform (in case it is scaled or rotated)
surface.LayoutTransform = null;
var size = new Size( 1600, 900 );
// Attentation: Measure and arrange the surface !
surface.Measure( size );
surface.Arrange( new Rect( size ) );
var renderBitmap = new RenderTargetBitmap( (int)size.Width, (int)size.Height, 96d, 96d, PixelFormats.Pbgra32 );
var bounds = VisualTreeHelper.GetDescendantBounds( surface );
var dv = new DrawingVisual();
using ( var ctx = dv.RenderOpen() )
{
var vb = new VisualBrush( surface );
ctx.DrawRectangle( vb, null, new Rect( new Point(), bounds.Size ) );
}
renderBitmap.Render( dv );
using ( var outStream = new FileStream( file, FileMode.OpenOrCreate, FileAccess.Write ) )
{
var encoder = new PngBitmapEncoder();
encoder.Frames.Add( BitmapFrame.Create( renderBitmap ) );
encoder.Save( outStream );
}
// Restore previously saved layout
surface.LayoutTransform = transform;
}
/// <summary>
/// Renders the brush.
/// </summary>
/// <param name="path">
/// The path.
/// </param>
/// <param name="brush">
/// The brush.
/// </param>
/// <param name="w">
/// The w.
/// </param>
/// <param name="h">
/// The h.
/// </param>
public static void RenderBrush(string path, Brush brush, int w, int h)
{
var ib = brush as ImageBrush;
if (ib != null)
{
var bi = ib.ImageSource as BitmapImage;
if (bi != null)
{
w = bi.PixelWidth;
h = bi.PixelHeight;
}
}
var bmp = new RenderTargetBitmap(w, h, 96, 96, PixelFormats.Pbgra32);
var rect = new Grid
{
Background = brush,
Width = 1,
Height = 1,
LayoutTransform = new ScaleTransform(w, h)
};
rect.Arrange(new Rect(0, 0, w, h));
bmp.Render(rect);
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bmp));
using (Stream stm = File.Create(path))
{
encoder.Save(stm);
}
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
// Converts a Canvas to an image source
var canvas = value as Canvas;
if (canvas == null)
{
return null;
}
var param = parameter as CanvasToImageSourceParameters;
double width = canvas.Width;
double height = canvas.Height;
if (param != null)
{
width = param.Width;
height = param.Height;
}
if (!canvas.IsMeasureValid)
{
canvas.Measure(new Size(width, height));
canvas.Arrange(new Rect(0, 0, width, height));
canvas.UpdateLayout();
}
var rtb = new RenderTargetBitmap((int)width, (int)height, 96d, 96d, PixelFormats.Pbgra32);
rtb.Render(canvas);
var bmp = GetBitmap(rtb);
return rtb;
}
protected override void RenderSample()
{
var canvas = new Canvas { Width = 10, Height = 10, SnapsToDevicePixels = true, Background = Brushes.Transparent };
canvas.Children.Add(new Path
{
Stroke = Stroke,
StrokeThickness = StrokeThickness,
Fill = Fill,
Data = new RectangleGeometry(new Rect(0, 0, 10, 10)),
});
canvas.Measure(new Size(canvas.Width, canvas.Height));
canvas.Arrange(new Rect(0, 0, canvas.Width, canvas.Height));
var dpiX = 96.0;
var dpiY = 96.0;
var source = PresentationSource.FromVisual(Application.Current.MainWindow);
if (source != null && source.CompositionTarget != null)
{
var matrix = source.CompositionTarget.TransformToDevice;
dpiX *= matrix.M11;
dpiY *= matrix.M22;
}
var rtb = new RenderTargetBitmap((int)Math.Round(canvas.Width), (int)Math.Round(canvas.Height), dpiX, dpiY, PixelFormats.Pbgra32);
rtb.Render(canvas);
SampleImageSource = rtb;
}
public void Convert(IEnumerable<IAssetImageSource> sources, string target, VisualAssetInfo visualAsset)
{
if (sources == null)
{
throw new ArgumentNullException("sources");
}
if (string.IsNullOrEmpty(target))
{
throw new ArgumentNullException("target");
}
if (visualAsset == null)
{
throw new ArgumentNullException("visualAsset");
}
var rectangle = this.GetRectangleBounds(visualAsset.Width, visualAsset.Height, visualAsset.Margin);
var drawingVisual = this.CreateDrawingVisual(sources, rectangle);
var targetBitmap = new RenderTargetBitmap(visualAsset.Width, visualAsset.Height, 96, 96, PixelFormats.Pbgra32);
targetBitmap.Render(drawingVisual);
var png = new PngBitmapEncoder();
png.Frames.Add(BitmapFrame.Create(targetBitmap));
using (var stream = new FileStream(target, FileMode.Create, FileAccess.Write))
{
png.Save(stream);
}
}
private static MemoryStream SaveDrawingImage(ImageSource drawingImage)
{
var image = new Image
{
Source = drawingImage
};
image.Arrange(new Rect(0, 0, drawingImage.Width, drawingImage.Height));
var settings = Settings.Default;
var renderTargetBitmap = new RenderTargetBitmap((int)drawingImage.Width, (int)drawingImage.Height, settings.ImageDPI, settings.ImageDPI, PixelFormats.Default);
renderTargetBitmap.Render(image);
Settings.Default.Save();
var encoder = new JpegBitmapEncoder
{
QualityLevel = settings.JpgQuality
};
encoder.Frames.Add(BitmapFrame.Create(renderTargetBitmap));
var memoryStream = new MemoryStream();
encoder.Save(memoryStream);
return memoryStream;
}
public Snapshot GetSnapshot(MediaPlayer mp)
{
DrawingVisual drawingVisual = new DrawingVisual();
DrawingContext drawingContext = drawingVisual.RenderOpen();
drawingContext.DrawVideo(mp, new Rect(0, 0, mp.NaturalVideoWidth, mp.NaturalVideoHeight));
drawingContext.Close();
System.Windows.Media.Imaging.RenderTargetBitmap bmp = new System.Windows.Media.Imaging.RenderTargetBitmap(mp.NaturalVideoWidth, mp.NaturalVideoHeight, 96, 96, PixelFormats.Pbgra32);
bmp.Render(drawingVisual);
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
Guid photoID = System.Guid.NewGuid();
String photolocation = photoID + ".jpg"; //file name
encoder.Frames.Add(BitmapFrame.Create(bmp));
using (var ms = new MemoryStream())
{
encoder.Save(ms);
var img = (Bitmap)Image.FromStream(ms);
var snapshot = Snapshot.FromBitmap(img);
return(snapshot);
}
}
private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
var bitmap = new RenderTargetBitmap((int)Math.Ceiling(Grid.RenderSize.Width), (int)Math.Ceiling(Grid.RenderSize.Height), 96, 96, PixelFormats.Default);
bitmap.Render(Grid);
Grid.Effect = new CircleRevealTransitionEffect
{
OldImage = new ImageBrush(bitmap),
Reverse = !ToggleButton.IsChecked.Value
};
TaskbarItemInfo = ToggleButton.IsChecked == true
? new TaskbarItemInfo {ProgressState = TaskbarItemProgressState.Indeterminate}
: new TaskbarItemInfo {ProgressState = TaskbarItemProgressState.None};
Application.Current.Resources["Dunno"] = ToggleButton.IsChecked == true ? Application.Current.Resources["Dunno2"] : Application.Current.Resources["Dunno1"];
Grid.Background = ToggleButton.IsChecked == true ? Brushes.Transparent : _background;
OnAirImage.Visibility = ToggleButton.IsChecked == true ? Visibility.Visible : Visibility.Collapsed;
_compositeNodeViewModel.ResetNodes();
_sw = Stopwatch.StartNew();
_timer?.Stop();
_timer = new DispatcherTimer(TimeSpan.FromMilliseconds(10), DispatcherPriority.Normal, Callback, Dispatcher);
}
protected override void OnUpdate(double[] values)
{
const double space = 3;
const double barwidth = 8;
int pts = values.Length / 2;
int width = 1000;//pts * (space + barwidth) - space;
int height = width / 4;
if (_bmp == null || width != _bmp.PixelWidth)
{
_bmp = new RenderTargetBitmap(width, height, 120, 96, PixelFormats.Pbgra32);
}
DrawingVisual drawingVisual = new DrawingVisual();
DrawingContext drawingContext = drawingVisual.RenderOpen();
Brush brush = DrawingBrush.Clone();
brush.Freeze();
double totalWidth = width / pts;
double totalBarWidth = totalWidth * ((barwidth) / (barwidth + space));
double totalSpace = totalWidth * ((space) / (barwidth + space));
for (int i = 0; i < pts; i++)
{
double x = i * totalWidth;
double y1 = height;
double y2 = y1 - values[i] * height;
drawingContext.DrawRectangle(brush, null, new Rect(x, y2, totalBarWidth, y1));
}
drawingContext.Close();
_bmp.Clear();
_bmp.Render(drawingVisual);
PART_visualationDisplay.Source = _bmp;
}
/// <summary>
/// Преобразует XAML Drawing/DrawingGroup в png base64 string
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="drawing"></param>
/// <returns>Base64 string containing png bitmap</returns>
public static string XamlDrawingToPngBase64String(int width, int height, Drawing drawing) {
var bitmapEncoder = new PngBitmapEncoder();
// The image parameters...
double dpiX = 96;
double dpiY = 96;
// The Visual to use as the source of the RenderTargetBitmap.
var drawingVisual = new DrawingVisual();
using (var drawingContext = drawingVisual.RenderOpen()) {
drawingContext.DrawDrawing(drawing);
}
var bounds = drawingVisual.ContentBounds;
var targetBitmap = new RenderTargetBitmap(
width * 10, height * 10, dpiX, dpiY,
PixelFormats.Pbgra32);
drawingVisual.Transform = new ScaleTransform(width * 10 / bounds.Width, height * 10 / bounds.Height);
targetBitmap.Render(drawingVisual);
// Encoding the RenderBitmapTarget as an image.
bitmapEncoder.Frames.Add(BitmapFrame.Create(targetBitmap));
byte[] values;
using (var str = new MemoryStream()) {
bitmapEncoder.Save(str);
values = str.ToArray();
}
return Convert.ToBase64String(values);
}
/// <summary>
/// Convert any control to a PngBitmapEncoder
/// </summary>
/// <param name="controlToConvert">The control to convert to an ImageSource</param>
/// <returns>The returned ImageSource of the controlToConvert</returns>
private static PngBitmapEncoder getImageFromControl(Control controlToConvert)
{
// save current canvas transform
Transform transform = controlToConvert.LayoutTransform;
// get size of control
Size sizeOfControl = new Size(controlToConvert.ActualWidth, controlToConvert.ActualHeight);
// measure and arrange the control
controlToConvert.Measure(sizeOfControl);
// arrange the surface
controlToConvert.Arrange(new Rect(sizeOfControl));
// craete and render surface and push bitmap to it
RenderTargetBitmap renderBitmap = new RenderTargetBitmap((Int32)sizeOfControl.Width, (Int32)sizeOfControl.Height, 96d, 96d, PixelFormats.Pbgra32);
// now render surface to bitmap
renderBitmap.Render(controlToConvert);
// encode png data
PngBitmapEncoder pngEncoder = new PngBitmapEncoder();
// puch rendered bitmap into it
pngEncoder.Frames.Add(BitmapFrame.Create(renderBitmap));
// return encoder
return pngEncoder;
}
/// <summary>
/// </summary>
/// <param name="source"> </param>
/// <param name="scale"> </param>
/// <param name="quality"> </param>
/// <returns> </returns>
public static byte[] GetJpgImage(UIElement source, double scale, int quality)
{
var actualHeight = source.RenderSize.Height;
var actualWidth = source.RenderSize.Width;
var renderHeight = actualHeight * scale;
var renderWidth = actualWidth * scale;
var renderTarget = new RenderTargetBitmap((int) renderWidth, (int) renderHeight, 96, 96, PixelFormats.Pbgra32);
var sourceBrush = new VisualBrush(source);
var drawingVisual = new DrawingVisual();
var drawingContext = drawingVisual.RenderOpen();
using (drawingContext)
{
drawingContext.PushTransform(new ScaleTransform(scale, scale));
drawingContext.DrawRectangle(sourceBrush, null, new Rect(new Point(0, 0), new Point(actualWidth, actualHeight)));
}
renderTarget.Render(drawingVisual);
var jpgEncoder = new JpegBitmapEncoder
{
QualityLevel = quality
};
jpgEncoder.Frames.Add(BitmapFrame.Create(renderTarget));
Byte[] imageArray;
using (var outputStream = new MemoryStream())
{
jpgEncoder.Save(outputStream);
imageArray = outputStream.ToArray();
}
return imageArray;
}
public static RenderTargetBitmap GetRenderTargetBitmap(this UIElement source, double scale)
{
if (source.RenderSize.Height == 0 || source.RenderSize.Width == 0)
return null;
double actualHeight = source.RenderSize.Height;
double actualWidth = source.RenderSize.Width;
double renderHeight = actualHeight*scale;
double renderWidth = actualWidth*scale;
var renderTarget = new RenderTargetBitmap((int) renderWidth, (int) renderHeight, 96, 96,
PixelFormats.Pbgra32);
var sourceBrush = new VisualBrush(source);
var drawingVisual = new DrawingVisual();
DrawingContext drawingContext = drawingVisual.RenderOpen();
using (drawingContext)
{
drawingContext.PushTransform(new ScaleTransform(scale, scale));
drawingContext.DrawRectangle(sourceBrush, null,
new Rect(new Point(0, 0), new Point(actualWidth, actualHeight)));
}
renderTarget.Render(drawingVisual);
return renderTarget;
}
private Color GetColorFromImage(Point p)
{
try
{
var bounds = VisualTreeHelper.GetDescendantBounds(this);
var rtb = new RenderTargetBitmap((int) bounds.Width, (int) bounds.Height, 96, 96, PixelFormats.Default);
rtb.Render(this);
byte[] arr;
var png = new PngBitmapEncoder();
png.Frames.Add(BitmapFrame.Create(rtb));
using (var stream = new MemoryStream())
{
png.Save(stream);
arr = stream.ToArray();
}
BitmapSource bitmap = BitmapFrame.Create(new MemoryStream(arr));
var pixels = new byte[4];
var cb = new CroppedBitmap(bitmap, new Int32Rect((int) p.X, (int) p.Y, 1, 1));
cb.CopyPixels(pixels, 4, 0);
return Color.FromArgb(pixels[3], pixels[2], pixels[1], pixels[0]);
}
catch (Exception)
{
return ColorBox.Color;
}
}
void loader_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
buff.UpdateLayout();
Canvas canvas = new Canvas();
canvas.Children.Add(buff);
canvas.Width = 512 * 13;
canvas.Height = 512 * 7;
canvas.UpdateLayout();
canvas.Measure(new Size((int)canvas.Width, (int)canvas.Height));
canvas.Arrange(new Rect(new Size((int)canvas.Width, (int)canvas.Height)));
int Height = ((int)(canvas.ActualHeight));
int Width = ((int)(canvas.ActualWidth));
RenderTargetBitmap _RenderTargetBitmap = new RenderTargetBitmap(Width, Height, 96, 96, PixelFormats.Pbgra32);
_RenderTargetBitmap.Render(buff);
Image img = new Image();
img.Source = _RenderTargetBitmap;
Viewer.PanoramaImage = _RenderTargetBitmap;
Title = "Demo.StreetView, enjoy! ;}";
}
unsafe bool Close()
{
CloseGroup();
if (image != null)
{
Control.Close();
var handler = (BitmapHandler)image.Handler;
var bmp = image.ToWpf();
var newbmp = new swmi.RenderTargetBitmap(bmp.PixelWidth, bmp.PixelHeight, bmp.DpiX, bmp.DpiY, swm.PixelFormats.Pbgra32);
newbmp.RenderWithCollect(visual);
if (!bmp.Format.HasAlpha())
{
// convert to non-alpha, as RenderTargetBitmap does not support anything other than Pbgra32
var wb = new swmi.WriteableBitmap(bmp.PixelWidth, bmp.PixelHeight, bmp.DpiX, bmp.DpiY, swm.PixelFormats.Bgr32, null);
var rect = new sw.Int32Rect(0, 0, bmp.PixelWidth, bmp.PixelHeight);
var pixels = new byte[bmp.PixelHeight * wb.BackBufferStride];
newbmp.CopyPixels(rect, pixels, wb.BackBufferStride, 0);
fixed(byte *ptr = pixels)
{
wb.WritePixels(rect, (IntPtr)ptr, pixels.Length, wb.BackBufferStride, 0, 0);
}
handler.SetBitmap(wb);
}
else
{
handler.SetBitmap(newbmp);
}
return(true);
}
return(false);
}
public Document CreatePdfDocument(Chart chart, string path)
{
RenderTargetBitmap renderBitmap = new RenderTargetBitmap(
(int) chart.ActualWidth,
(int) chart.ActualHeight,
96d,
96d,
PixelFormats.Pbgra32);
renderBitmap.Render(chart);
MemoryStream stream = new MemoryStream();
BitmapEncoder encoder = new BmpBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
encoder.Save(stream);
Bitmap bitmap = new Bitmap(stream);
System.Drawing.Image image = bitmap;
System.Drawing.Image resizedImage = ResizeImage(image, image.Width*2, image.Height);
Document doc = new Document(PageSize.A4);
PdfWriter.GetInstance(doc, new FileStream(path, FileMode.OpenOrCreate));
doc.Open();
Image pdfImage = Image.GetInstance(resizedImage, ImageFormat.Jpeg);
doc.Add(pdfImage);
doc.Close();
return doc;
}
public static Cursor CreateCursor(UIElement element, int xHotSpot,
int yHotSpot)
{
element.Measure(new Size(double.PositiveInfinity,
double.PositiveInfinity));
element.Arrange(new Rect(0, 0, element.DesiredSize.Width,
element.DesiredSize.Height));
RenderTargetBitmap rtb =
new RenderTargetBitmap((int)element.DesiredSize.Width,
(int)element.DesiredSize.Height, 96, 96, PixelFormats.Pbgra32);
rtb.Render(element);
PngBitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(rtb));
MemoryStream ms = new MemoryStream();
encoder.Save(ms);
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(ms);
ms.Close();
ms.Dispose();
Cursor cur = InternalCreateCursor(bmp, xHotSpot, yHotSpot);
bmp.Dispose();
return cur;
}
public static RenderTargetBitmap GetImage(UIElement fe, Brush background = null, Size sz = default(Size), int dpi = 144)
{
if (sz.Width < alib.Math.math.ε || sz.Height < alib.Math.math.ε)
{
fe.Measure(util.infinite_size);
sz = fe.DesiredSize; //VisualTreeHelper.GetContentBounds(fe).Size; //
}
DrawingVisual dv = new DrawingVisual();
RenderOptions.SetEdgeMode(dv, EdgeMode.Aliased);
using (DrawingContext ctx = dv.RenderOpen())
{
Rect r = new Rect(0, 0, sz.Width, sz.Height);
if (background != null)
ctx.DrawRectangle(background, null, r);
VisualBrush br = new VisualBrush(fe);
br.AutoLayoutContent = true;
ctx.DrawRectangle(br, null, r);
}
Double f = dpi / 96.0;
RenderTargetBitmap bitmap = new RenderTargetBitmap(
(int)(sz.Width * f) + 1,
(int)(sz.Height * f) + 1,
dpi,
dpi,
PixelFormats.Pbgra32);
bitmap.Render(dv);
return bitmap;
}
/// <summary>
/// Generates an image of each page in the year book
/// and saves it to the src folder
/// </summary>
/// <param name="bv"></param>
/// <param name="folderloc"></param>
private static void RenderPages(BookViewer bv, string folderloc)
{
int currentpage = bv.ViewIndex;
//loops though each page
foreach (Page p in bv.CurrentBook.Pages)
{
bv.ViewIndex = p.PageNumber;
//forces the canvas to re-render
BookViewer.DesignerCanvas.UpdateLayout();
//takes a picture of the canvas
RenderTargetBitmap rtb = new RenderTargetBitmap(PaperSize.Pixel.PaperWidth, PaperSize.Pixel.PaperHeight, 96, 96, PixelFormats.Default);
rtb.Render(BookViewer.DesignerCanvas);
//getting the bleed margin
Int32Rect bleedmargin = new Int32Rect((PaperSize.Pixel.PaperWidth - PaperSize.Pixel.BleedWidth) / 2, (PaperSize.Pixel.PaperHeight - PaperSize.Pixel.BleedHeight) / 2, PaperSize.Pixel.BleedWidth, PaperSize.Pixel.BleedHeight);
//cropping the image
CroppedBitmap cb = new CroppedBitmap(rtb, bleedmargin);
//encodes the image in png format
PngBitmapEncoder pbe = new PngBitmapEncoder();
pbe.Frames.Add(BitmapFrame.Create(cb));
//saves the resulting image
FileStream fs = File.Open(folderloc + "\\src\\" + (p.PageNumber+1) + ".png", FileMode.Create);
pbe.Save(fs);
fs.Flush();
fs.Close();
}
bv.ViewIndex = currentpage;
}
/// <summary>
/// Saves the full chart to a file, including technical analysis.
/// </summary>
/// <param name="filename">The file to write to.</param>
public void SaveAsImage(string filename)
{
if (string.IsNullOrEmpty(filename))
throw new ArgumentNullException();
var extension = Path.GetExtension(filename);
if (string.IsNullOrEmpty(extension))
throw new ArgumentNullException();
BitmapEncoder bitmapEncoder;
extension = extension.ToLower();
if (extension == ".png")
bitmapEncoder = new PngBitmapEncoder();
else if (extension == ".jpg" || extension == ".jpeg")
bitmapEncoder = new JpegBitmapEncoder();
else if (extension == ".gif")
bitmapEncoder = new GifBitmapEncoder();
else if (extension == ".bmp")
bitmapEncoder = new BmpBitmapEncoder();
else throw new ArgumentException("Cannot find a BitmapEncoder for this file type.");
var renderTargetBitmap = new RenderTargetBitmap((int)this.ActualWidth, (int)this.ActualHeight, 96, 96, PixelFormats.Pbgra32);
foreach (var child in LogicalTreeHelper.GetChildren(this))
{
if (child is ChartPanel)
renderTargetBitmap.Render((ChartPanel)child);
}
bitmapEncoder.Frames.Add(BitmapFrame.Create(renderTargetBitmap));
using (Stream stream = File.Create(filename))
{
bitmapEncoder.Save(stream);
}
}
public static ImageSource GetNewMessagesNotificationOverlay(Window window, DataTemplate template, int count = 0)
{
if (window == null)
return null;
var presentation = PresentationSource.FromVisual(window);
if (presentation == null)
return null;
Matrix m = presentation.CompositionTarget.TransformToDevice;
double dx = m.M11;
double dy = m.M22;
double iconWidth = 16.0 * dx;
double iconHeight = 16.0 * dy;
string countText = count.ToString();
RenderTargetBitmap bmp = new RenderTargetBitmap((int) iconWidth, (int) iconHeight, 96, 96, PixelFormats.Default);
ContentControl root = new ContentControl
{
ContentTemplate = template,
Content = count > 99 ? "…" : countText
};
root.Arrange(new Rect(0, 0, iconWidth, iconHeight));
bmp.Render(root);
return bmp;
}
public static byte[] GetScreenShot(this UIElement source, double scale, int quality)
{
double renderHeight = source.RenderSize.Height * scale;
double renderWidth = source.RenderSize.Width * scale;
RenderTargetBitmap renderTarget = new RenderTargetBitmap((int)renderWidth, (int)renderHeight, 96, 96, PixelFormats.Pbgra32);
VisualBrush sourceBrush = new VisualBrush(source);
DrawingVisual drawingVisual = new DrawingVisual();
DrawingContext drawingContext = drawingVisual.RenderOpen();
using (drawingContext)
{
drawingContext.PushTransform(new ScaleTransform(scale, scale));
drawingContext.DrawRectangle(sourceBrush, null, new Rect(new Point(0, 0), new Point(source.RenderSize.Width, source.RenderSize.Height)));
}
renderTarget.Render(drawingVisual);
JpegBitmapEncoder jpgEncoder = new JpegBitmapEncoder();
jpgEncoder.QualityLevel = quality;
jpgEncoder.Frames.Add(BitmapFrame.Create(renderTarget));
Byte[] image;
using (MemoryStream outputStream = new MemoryStream())
{
jpgEncoder.Save(outputStream);
image = outputStream.ToArray();
}
return image;
}
public void SetPreviewElement(FrameworkElement element)
{
double x = 0;
double y = 0;
GetCurrentDPI(out x, out y);
// Does the DrawingBrush thing seem a little hacky? Yeah, it's a necessary hack. See:
// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=364041
Rect bounds = VisualTreeHelper.GetDescendantBounds(element);
RenderTargetBitmap r = new RenderTargetBitmap((int)(element.ActualWidth * x / 96), (int)(element.ActualHeight * y / 96), (int)x, (int)y, PixelFormats.Pbgra32);
DrawingVisual dv = new DrawingVisual();
using (DrawingContext ctx = dv.RenderOpen()) {
VisualBrush vb = new VisualBrush(element);
ctx.DrawRectangle(vb, null, new Rect(new Point(), bounds.Size));
}
r.Render(dv);
DragImage = r;
InvalidateMeasure();
}
public void SaveFrameworkElementToImage(FrameworkElement ui, string filename)
{
System.IO.FileStream ms = new System.IO.FileStream(filename, System.IO.FileMode.Create);
System.Windows.Media.Imaging.RenderTargetBitmap bmp = new System.Windows.Media.Imaging.RenderTargetBitmap((int)ui.ActualWidth, (int)ui.ActualHeight, 96d, 96d, System.Windows.Media.PixelFormats.Pbgra32);
bmp.Render(ui);
System.Windows.Media.Imaging.JpegBitmapEncoder encoder = new System.Windows.Media.Imaging.JpegBitmapEncoder();
encoder.Frames.Add(System.Windows.Media.Imaging.BitmapFrame.Create(bmp));
encoder.Save(ms);
ms.Close();
//File.Copy(filename, filename, true);
}
public void CopyImage(RenderTargetBitmap image1) {
System.Windows.Media.Imaging.RenderTargetBitmap bmpCopied =
new System.Windows.Media.Imaging.RenderTargetBitmap(
(int)Math.Round(width), (int)Math.Round(height), 96, 96, PixelFormats.Default);
DrawingVisual dv = new DrawingVisual();
using (DrawingContext dc = dv.RenderOpen())
{
VisualBrush vb = new VisualBrush(image1);
dc.DrawRectangle(vb, null, new Rect(new Point(), new Size(width, height)));
}
bmpCopied.Render(dv);
Clipboard.SetImage(bmpCopied); } }
bool Close()
{
if (image != null)
{
Control.Close();
var handler = image.Handler as BitmapHandler;
var bmp = handler.Control;
var newbmp = new swmi.RenderTargetBitmap(bmp.PixelWidth, bmp.PixelHeight, bmp.DpiX, bmp.DpiY, swm.PixelFormats.Pbgra32);
newbmp.Render(visual);
handler.SetBitmap(newbmp);
return(true);
}
return(false);
}
public swmi.BitmapFrame Get(swmi.BitmapSource image, float scale, int width, int height, swm.BitmapScalingMode scalingMode)
{
if (width <= 0 || height <= 0 || scale <= 0)
{
return(null);
}
var _cachedFrame = _cachedFrameReference?.Target as swmi.BitmapFrame;
// if parameters are the same, return cached bitmap
if (_cachedFrame != null && scale == _scale && width == _width && height == _height && scalingMode == _scalingMode)
{
return(_cachedFrame);
}
// generate a new bitmap with the desired size & scale.
var scaledwidth = (int)Math.Round(width * scale);
var scaledheight = (int)Math.Round(height * scale);
if (scaledwidth <= 0 || scaledheight <= 0)
{
return(null);
}
var group = new swm.DrawingGroup();
swm.RenderOptions.SetBitmapScalingMode(group, scalingMode);
group.Children.Add(new swm.ImageDrawing(image, new sw.Rect(0, 0, width, height)));
var targetVisual = new swm.DrawingVisual();
using (var targetContext = targetVisual.RenderOpen())
targetContext.DrawDrawing(group);
// note, this uses a GDI handle, which are limited (only 5000 or so can be created).
// There's no way to get around it other than just not creating that many and using GC.Collect/WaitForPendingFinalizers.
// we can't do it in Eto as it'd be a serious performance hit.
var target = new swmi.RenderTargetBitmap(scaledwidth, scaledheight, 96 * scale, 96 * scale, swm.PixelFormats.Default);
target.Render(targetVisual);
target.Freeze();
_cachedFrame = swmi.BitmapFrame.Create(target);
_cachedFrame.Freeze();
_scale = scale;
_width = width;
_height = height;
_scalingMode = scalingMode;
_cachedFrameReference = new WeakReference(_cachedFrame);
return(_cachedFrame);
}
bool Close()
{
CloseGroup();
if (image != null)
{
Control.Close();
var handler = (BitmapHandler)image.Handler;
var bmp = image.ToWpf();
var newbmp = new swmi.RenderTargetBitmap(bmp.PixelWidth, bmp.PixelHeight, bmp.DpiX, bmp.DpiY, swm.PixelFormats.Pbgra32);
newbmp.RenderWithCollect(visual);
handler.SetBitmap(newbmp);
return(true);
}
return(false);
}
public void Clear(SolidBrush brush)
{
var rect = this.ClipBounds;
if (drawingVisual != null)
{
// bitmap
Control.Close();
var newbmp = new swmi.RenderTargetBitmap((int)bounds.Width, (int)bounds.Height, 96, 96, swm.PixelFormats.Pbgra32);
newbmp.Render(visual);
swm.Geometry maskgeometry;
if (clipPath != null)
{
maskgeometry = clipPath.ToWpf();
}
else
{
maskgeometry = new swm.RectangleGeometry(rect.ToWpf());
}
var boundsgeometry = new swm.RectangleGeometry(this.bounds);
maskgeometry = swm.Geometry.Combine(boundsgeometry, maskgeometry, swm.GeometryCombineMode.Exclude, null);
var dr = new swm.GeometryDrawing(swm.Brushes.Black, null, maskgeometry);
var db = new swm.DrawingBrush(dr);
//db.Transform = new swm.TranslateTransform (0.5, 0.5);
Control = drawingVisual.RenderOpen();
PushGuideLines(bounds.X, bounds.Y, bounds.Width, bounds.Height);
Control.PushOpacityMask(db);
Control.DrawImage(newbmp, this.bounds);
Control.Pop();
TransformStack.PushAll();
ApplyClip();
}
else
{
// drawable
if (brush == null || brush.Color.A < 1.0f)
{
Widget.FillRectangle(Brushes.Black(Generator), rect);
}
}
if (brush != null)
{
Widget.FillRectangle(brush, rect);
}
}
public RenderTargetBitmap GetNewRenderTargetBitmap(FrameKey frameKey, CancellationTokenSource cancellationTokenSource)
{
RenderTargetBitmap renderTargetBitmap = null;
while (renderTargetBitmap == null && !cancellationTokenSource.IsCancellationRequested)
{
//tiffBitmapDecoder.Dispatcher.Invoke(new Action(() =>
System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
{
var bitmapSource = GetTiffBitmapSource(frameKey.FileName, frameKey.FrameIndex, cancellationTokenSource);
renderTargetBitmap = new System.Windows.Media.Imaging.RenderTargetBitmap(bitmapSource.PixelWidth, bitmapSource.PixelHeight, 96, 96, System.Windows.Media.PixelFormats.Default);
}), TimeSpan.FromMilliseconds(500), null);
}
//Console.WriteLine("renderTargetBitmap created " + frameKey.ToString());
return(renderTargetBitmap);
}
public void Clear(SolidBrush brush)
{
var rect = clipBounds ?? initialClip;
if (drawingVisual != null)
{
// bitmap
Control.Close();
var newbmp = new swmi.RenderTargetBitmap((int)bounds.Width, (int)bounds.Height, 96, 96, swm.PixelFormats.Pbgra32);
newbmp.RenderWithCollect(visual);
swm.Geometry maskgeometry;
if (clipPath != null)
{
maskgeometry = clipPath;
}
else
{
maskgeometry = new swm.RectangleGeometry(rect.ToWpf());
}
var boundsgeometry = new swm.RectangleGeometry(bounds);
maskgeometry = swm.Geometry.Combine(boundsgeometry, maskgeometry, swm.GeometryCombineMode.Exclude, null);
var dr = new swm.GeometryDrawing(swm.Brushes.Black, null, maskgeometry);
var db = new swm.DrawingBrush(dr);
//db.Transform = new swm.TranslateTransform (0.5, 0.5);
Control = drawingVisual.RenderOpen();
Control.PushGuidelineSet(new swm.GuidelineSet(new [] { bounds.Left, bounds.Right }, new [] { bounds.Top, bounds.Bottom }));
Control.PushOpacityMask(db);
Control.DrawImage(newbmp, bounds);
Control.Pop();
ApplyAll();
}
else
{
// drawable
if (brush == null || brush.Color.A < 1.0f)
{
Widget.FillRectangle(Brushes.Black, rect);
}
}
if (brush != null)
{
Widget.FillRectangle(brush, rect);
}
}
public void SaveFrameworkElementToImage(FrameworkElement ui, string filelocation, string filename)
{
System.IO.FileStream ms = new System.IO.FileStream(filename, System.IO.FileMode.Create);
System.Windows.Media.Imaging.RenderTargetBitmap bmp = new System.Windows.Media.Imaging.RenderTargetBitmap
((int)ui.ActualWidth, (int)ui.ActualHeight, 96d, 96d, System.Windows.Media.PixelFormats.Pbgra32);
bmp.Render(ui);
System.Windows.Media.Imaging.JpegBitmapEncoder encoder = new System.Windows.Media.Imaging.JpegBitmapEncoder();
encoder.Frames.Add(System.Windows.Media.Imaging.BitmapFrame.Create(bmp));
encoder.Save(ms);
ms.Close();
string fs = AppDomain.CurrentDomain.BaseDirectory + "\\waveimage\\" + filelocation;
if (!File.Exists(fs))
{
Directory.CreateDirectory(fs);
}
File.Copy(filename, fs + "\\" + filename + ".jpg", true);
}
static swmi.BitmapFrame Resize(swmi.BitmapSource image, float scale, int width, int height, swm.BitmapScalingMode scalingMode)
{
var group = new swm.DrawingGroup();
swm.RenderOptions.SetBitmapScalingMode(group, scalingMode);
group.Children.Add(new swm.ImageDrawing(image, new sw.Rect(0, 0, width, height)));
var targetVisual = new swm.DrawingVisual();
var targetContext = targetVisual.RenderOpen();
targetContext.DrawDrawing(group);
width = (int)Math.Round(width * scale);
height = (int)Math.Round(height * scale);
var target = new swmi.RenderTargetBitmap(width, height, 96 * scale, 96 * scale, swm.PixelFormats.Default);
targetContext.Close();
target.Render(targetVisual);
return(swmi.BitmapFrame.Create(target));
}
public override object Resize(object handle, double width, double height)
{
var oldImg = (SWMI.BitmapSource)handle;
width = WidthToDPI(oldImg, width);
height = HeightToDPI(oldImg, height);
SWM.DrawingVisual visual = new SWM.DrawingVisual();
using (SWM.DrawingContext ctx = visual.RenderOpen())
{
ctx.DrawImage(oldImg, new System.Windows.Rect(0, 0, width, height));
}
SWMI.RenderTargetBitmap bmp = new SWMI.RenderTargetBitmap((int)width, (int)height, oldImg.DpiX, oldImg.DpiY, oldImg.Format);
bmp.Render(visual);
return(bmp);
}
public void Create(Image image, int width, int height, ImageInterpolation interpolation)
{
ApplicationHandler.InvokeIfNecessary(() => {
var source = image.ToWpf();
// use drawing group to allow for better quality scaling
var group = new swm.DrawingGroup();
swm.RenderOptions.SetBitmapScalingMode(group, interpolation.ToWpf());
group.Children.Add(new swm.ImageDrawing(source, new sw.Rect(0, 0, width, height)));
var drawingVisual = new swm.DrawingVisual();
using (var drawingContext = drawingVisual.RenderOpen())
drawingContext.DrawDrawing(group);
var resizedImage = new swm.Imaging.RenderTargetBitmap(width, height, source.DpiX, source.DpiY, swm.PixelFormats.Default);
resizedImage.Render(drawingVisual);
Control = resizedImage;
});
}
ImageSource RenderFrame(ApplicationContext actx, double scaleFactor, double width, double height)
{
ImageDescription idesc = new ImageDescription()
{
Alpha = 1,
Size = new Size(width * scaleFactor, height * scaleFactor)
};
SWM.DrawingVisual visual = new SWM.DrawingVisual();
using (SWM.DrawingContext ctx = visual.RenderOpen()) {
Draw(actx, ctx, 1, 0, 0, idesc);
}
SWMI.RenderTargetBitmap bmp = new SWMI.RenderTargetBitmap((int)idesc.Size.Width, (int)idesc.Size.Height, 96, 96, PixelFormats.Pbgra32);
bmp.Render(visual);
AddFrame(bmp);
return(bmp);
}
public override object Crop(object handle, int srcX, int srcY, int w, int h)
{
var oldImg = (SWMI.BitmapSource)handle;
double width = WidthToDPI(oldImg, w);
double height = HeightToDPI(oldImg, h);
SWM.DrawingVisual visual = new SWM.DrawingVisual();
using (SWM.DrawingContext ctx = visual.RenderOpen())
{
//Not sure whether this actually works, untested
ctx.DrawImage(oldImg, new System.Windows.Rect(-srcX, -srcY, srcX + width, srcY + height));
}
SWMI.RenderTargetBitmap bmp = new SWMI.RenderTargetBitmap((int)width, (int)height, oldImg.DpiX, oldImg.DpiY, oldImg.Format);
bmp.Render(visual);
return(bmp);
}
ImageSource RenderFrame(ApplicationContext actx, double scaleFactor, ImageDescription idesc)
{
SWM.DrawingVisual visual = new SWM.DrawingVisual();
using (SWM.DrawingContext ctx = visual.RenderOpen()) {
ctx.PushTransform(new ScaleTransform(scaleFactor, scaleFactor));
Draw(actx, ctx, scaleFactor, 0, 0, idesc);
ctx.Pop();
}
SWMI.RenderTargetBitmap bmp = new SWMI.RenderTargetBitmap((int)(idesc.Size.Width * scaleFactor), (int)(idesc.Size.Height * scaleFactor), 96, 96, PixelFormats.Pbgra32);
bmp.Render(visual);
var f = new ImageFrame(bmp, idesc.Size.Width, idesc.Size.Height);
if (drawCallback == null)
{
AddFrame(f);
}
return(bmp);
}
private void ControlToRender_OnRendered(System.Windows.Media.Imaging.RenderTargetBitmap bitmapRend)
{
CurrentHeight = 0;
if (Controller != null && bitmapRend == null)
{
OpenVR.Overlay.ClearOverlayTexture(this.Handle);
if (this.CurrentBitmap != null)
{
this.CurrentBitmap.Dispose();
this.CurrentBitmap = null;
}
return;
}
System.IO.MemoryStream stream = new System.IO.MemoryStream();
BitmapEncoder encoder = new BmpBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmapRend));
encoder.Save(stream);
CurrentBitmap = new System.Drawing.Bitmap(stream);
RenderBitmap();
}
ImageSource RenderFrame(ApplicationContext actx, double scaleFactor, double width, double height)
{
ImageDescription idesc = new ImageDescription()
{
Alpha = 1,
Size = new Size(width, height)
};
SWM.DrawingVisual visual = new SWM.DrawingVisual();
using (SWM.DrawingContext ctx = visual.RenderOpen()) {
ctx.PushTransform(new ScaleTransform(scaleFactor, scaleFactor));
Draw(actx, ctx, scaleFactor, 0, 0, idesc);
ctx.Pop();
}
SWMI.RenderTargetBitmap bmp = new SWMI.RenderTargetBitmap((int)(width * scaleFactor), (int)(height * scaleFactor), 96, 96, PixelFormats.Pbgra32);
bmp.Render(visual);
var f = new ImageFrame(bmp, width, height);
AddFrame(f);
return(bmp);
}
// since inheritance of Window does not work, the eventhandler have to be static methods and added after generation of the Window object
// keyboard is pressed
private static void InkCanvas_KeyDown(object sender, KeyEventArgs e)
{
Key Taste = e.Key;
// the sender object is the object that generated the event
InkCanvas objInkCanvas = (InkCanvas)sender;
if (Keyboard.IsKeyDown(Key.RightCtrl) || Keyboard.IsKeyDown(Key.LeftCtrl))
// the following line only works with .Net 4.x
// if (Keyboard.Modifiers.HasFlag(ModifierKeys.Control))
{ // if Ctrl is pressed
switch (Taste)
{
case Key.C: // copy marked area
objInkCanvas.CopySelection();
break;
case Key.O: // open ink drawing
Microsoft.Win32.OpenFileDialog objOpenDialog = new Microsoft.Win32.OpenFileDialog();
objOpenDialog.Filter = "isf files (*.isf)|*.isf";
if ((bool)objOpenDialog.ShowDialog())
{
FileStream objFileStream = new FileStream(objOpenDialog.FileName, FileMode.Open);
objInkCanvas.Strokes.Add(new StrokeCollection(objFileStream));
objFileStream.Dispose();
}
break;
case Key.P: // save grafic as PNG file
Microsoft.Win32.SaveFileDialog objPNGDialog = new Microsoft.Win32.SaveFileDialog();
objPNGDialog.Filter = "png files (*.png)|*.png";
if ((bool)objPNGDialog.ShowDialog())
{
FileStream objFileStream = new FileStream(objPNGDialog.FileName, FileMode.Create);
System.Windows.Media.Imaging.RenderTargetBitmap objRenderBitmap = new System.Windows.Media.Imaging.RenderTargetBitmap((int)objInkCanvas.ActualWidth, (int)objInkCanvas.ActualHeight, 96.0, 96.0, System.Windows.Media.PixelFormats.Default);
objRenderBitmap.Render(objInkCanvas);
System.Windows.Media.Imaging.BitmapFrame objBitmapFrame = System.Windows.Media.Imaging.BitmapFrame.Create(objRenderBitmap);
System.Windows.Media.Imaging.PngBitmapEncoder objImgEncoder = new System.Windows.Media.Imaging.PngBitmapEncoder();
// alternative for JPG: System.Windows.Media.Imaging.JpegBitmapEncoder objImgEncoder = new System.Windows.Media.Imaging.JpegBitmapEncoder();
objImgEncoder.Frames.Add(objBitmapFrame);
objImgEncoder.Save(objFileStream);
objFileStream.Dispose();
}
break;
case Key.S: // save ink drawing
Microsoft.Win32.SaveFileDialog objSaveDialog = new Microsoft.Win32.SaveFileDialog();
objSaveDialog.Filter = "isf files (*.isf)|*.isf";
if ((bool)objSaveDialog.ShowDialog())
{
FileStream objFileStream = new FileStream(objSaveDialog.FileName, FileMode.Create);
objInkCanvas.Strokes.Save(objFileStream);
objFileStream.Dispose();
}
break;
case Key.V: // paste marked area
objInkCanvas.Paste();
break;
case Key.X: // cut marked area
objInkCanvas.CutSelection();
break;
}
}
else
{ // no Ctrl key is pressed
if (Keyboard.Modifiers == ModifierKeys.None)
{ // only when no other modifier keys are pressed
switch (Taste)
{
case Key.B: // next background color
Brush ActualBackColor = (Brush)BrushQueue.Dequeue();
BrushQueue.Enqueue(ActualBackColor);
objInkCanvas.Background = ActualBackColor;
break;
case Key.C: // clear window content
objInkCanvas.Strokes.Clear();
break;
case Key.D: // switch to draw mode
if (objInkCanvas.DefaultDrawingAttributes.IsHighlighter)
{
StoreHighLightSizeWidth = objInkCanvas.DefaultDrawingAttributes.Width;
StoreHighLightSizeHeight = objInkCanvas.DefaultDrawingAttributes.Height;
StoreHighLightColor = objInkCanvas.DefaultDrawingAttributes.Color;
objInkCanvas.DefaultDrawingAttributes.StylusTip = StylusTip.Ellipse;
objInkCanvas.DefaultDrawingAttributes.IsHighlighter = false;
objInkCanvas.DefaultDrawingAttributes.Color = StoreInkColor;
objInkCanvas.DefaultDrawingAttributes.Height = StoreInkSizeHeight;
objInkCanvas.DefaultDrawingAttributes.Width = StoreInkSizeWidth;
}
objInkCanvas.EditingMode = InkCanvasEditingMode.Ink;
break;
case Key.E: // // switch to erase mode (and toggle it)
switch (objInkCanvas.EditingMode)
{
case InkCanvasEditingMode.EraseByStroke:
objInkCanvas.EditingMode = InkCanvasEditingMode.EraseByPoint;
break;
case InkCanvasEditingMode.EraseByPoint:
objInkCanvas.EditingMode = InkCanvasEditingMode.EraseByStroke;
break;
case InkCanvasEditingMode.Ink:
objInkCanvas.EditingMode = InkCanvasEditingMode.EraseByPoint;
break;
}
break;
case Key.H: // switch to highlight mode
if (!objInkCanvas.DefaultDrawingAttributes.IsHighlighter)
{
StoreInkSizeWidth = objInkCanvas.DefaultDrawingAttributes.Width;
StoreInkSizeHeight = objInkCanvas.DefaultDrawingAttributes.Height;
StoreInkColor = objInkCanvas.DefaultDrawingAttributes.Color;
objInkCanvas.DefaultDrawingAttributes.Color = StoreHighLightColor;
}
objInkCanvas.EditingMode = InkCanvasEditingMode.Ink;
objInkCanvas.DefaultDrawingAttributes.IsHighlighter = true;
objInkCanvas.DefaultDrawingAttributes.StylusTip = StylusTip.Rectangle;
if (StoreHighLightSizeWidth > 0.0)
{
objInkCanvas.DefaultDrawingAttributes.Height = StoreHighLightSizeHeight;
objInkCanvas.DefaultDrawingAttributes.Width = StoreHighLightSizeWidth;
}
break;
case Key.N: // next foreground color
Color ActualFrontColor = (Color)ColorQueue.Dequeue();
ColorQueue.Enqueue(ActualFrontColor);
objInkCanvas.DefaultDrawingAttributes.Color = ActualFrontColor;
break;
case Key.Q: // close window
// event is handled now
e.Handled = true;
// parent object is Window
((Window)(objInkCanvas).Parent).Close();
break;
case Key.S: // start marking
objInkCanvas.Select(new System.Windows.Ink.StrokeCollection());
break;
case Key.OemMinus: // shrink brush
switch (objInkCanvas.EditingMode)
{
case InkCanvasEditingMode.EraseByPoint:
if (objInkCanvas.EraserShape.Width > 3.0)
{
objInkCanvas.EraserShape = new RectangleStylusShape(objInkCanvas.EraserShape.Width - 2.0, objInkCanvas.EraserShape.Height - 2.0);
// size change needs refresh to display
objInkCanvas.EditingMode = InkCanvasEditingMode.None;
objInkCanvas.EditingMode = InkCanvasEditingMode.EraseByPoint;
}
break;
case InkCanvasEditingMode.Ink:
if (objInkCanvas.DefaultDrawingAttributes.Height > 3.0)
{
objInkCanvas.DefaultDrawingAttributes.Height = objInkCanvas.DefaultDrawingAttributes.Height - 2.0;
objInkCanvas.DefaultDrawingAttributes.Width = objInkCanvas.DefaultDrawingAttributes.Width - 2.0;
}
break;
}
break;
case Key.OemPlus: // enlarge brush
switch (objInkCanvas.EditingMode)
{
case InkCanvasEditingMode.EraseByPoint:
if (objInkCanvas.EraserShape.Width < 50.0)
{
objInkCanvas.EraserShape = new RectangleStylusShape(objInkCanvas.EraserShape.Width + 2.0, objInkCanvas.EraserShape.Height + 2.0);
// size change needs refresh to display
objInkCanvas.EditingMode = InkCanvasEditingMode.None;
objInkCanvas.EditingMode = InkCanvasEditingMode.EraseByPoint;
}
break;
case InkCanvasEditingMode.Ink:
if (objInkCanvas.DefaultDrawingAttributes.Height < 50.0)
{
objInkCanvas.DefaultDrawingAttributes.Height = objInkCanvas.DefaultDrawingAttributes.Height + 2.0;
objInkCanvas.DefaultDrawingAttributes.Width = objInkCanvas.DefaultDrawingAttributes.Width + 2.0;
}
break;
}
break;
}
}
}
}
public static unsafe GrayScaleLetterGlyph CreateGlyph(Typeface typeface, GlyphTypeface glyphTypeface, double size, char ch)
{
if (ch == ' ')
{
return(CreateSpaceGlyph(glyphTypeface, size));
}
FormattedText text = new FormattedText(string.Empty + ch,
CultureInfo.InvariantCulture,
FlowDirection.LeftToRight,
typeface,
size,
Brushes.White);
int width = (int)Math.Ceiling(DpiDetector.DpiXKoef * text.Width);
int height = (int)Math.Ceiling(DpiDetector.DpiYKoef * text.Height);
if (width == 0 || height == 0)
{
return(null);
}
DrawingVisual drawingVisual = new DrawingVisual();
DrawingContext drawingContext = drawingVisual.RenderOpen();
drawingContext.DrawRectangle(Brushes.Black, new Pen(), new Rect(0, 0, width, height));
drawingContext.DrawText(text, new Point(0, 0));
drawingContext.Close();
RenderTargetBitmap bmp = new RenderTargetBitmap(width, height, DpiDetector.DpiXKoef * 96, DpiDetector.DpiYKoef * 96, PixelFormats.Pbgra32);
bmp.Render(drawingVisual);
var res = new List <Item>();
var pixbmp = new WriteableBitmap(bmp);
using (var ctx = new BitmapContext(pixbmp))
{
var pixels = ctx.Pixels;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int color = pixels[(y * width) + x];
byte r, g, b;
double avg;
r = (byte)((color >> 16) & 0xFF);
g = (byte)((color >> 8) & 0xFF);
b = (byte)((color) & 0xFF);
avg = (0.299 * r) + (0.587 * g) + (0.114 * b);
if (avg >= 1)
{
res.Add(new Item
{
X = (short)x,
Y = (short)y,
Alpha = (int)Math.Round(avg / 255.0 * 0x1000),
});
}
}
}
}
return(new GrayScaleLetterGlyph
{
Width = width,
Height = height,
Ch = ch,
Items = res.ToArray(),
});
}
public DrawGraphicsOnBitmap()
{
Title = "Draw Graphics on Bitmap";
// ��Ʈ���� ������� �����ϱ� ���� ����� ������.
Background = Brushes.Khaki;
// RenderTargetBitmap ������.
RenderTargetBitmap renderbitmap = new RenderTargetBitmap(100, 100, 96, 96, PixelFormats.Default);
// DrawingVisual ��ü�� ������.
DrawingVisual drawvis = new DrawingVisual();
DrawingContext dc = drawvis.RenderOpen(); // Render �ҵ� ȣ��
dc.DrawRoundedRectangle(Brushes.Blue, new Pen(Brushes.Red, 10),
new Rect(25, 25, 50, 50), 10, 10);
dc.Close();
// RenderTargetBitmap ���� DrawingVisual ��ü�� ��.
renderbitmap.Render(drawvis);
// �̹��� ��ä ���� -> ������Ƽ ����
Image img = new Image();
img.Source = renderbitmap;
// ���
Content = img;
}
