public static RenderTargetBitmap SaveCanvasToBitmap(Canvas canvas)
{
// Save current canvas transform
Transform transform = canvas.LayoutTransform;
// reset current transform (in case it is scaled or rotated)
canvas.LayoutTransform = null;
// Get the size of canvas
Size size = new Size(canvas.Width, canvas.Height);
// Measure and arrange the surface
// VERY IMPORTANT
canvas.Measure(size);
canvas.Arrange(new Rect(size));
// Create a render bitmap and push the surface to it
RenderTargetBitmap renderBitmap =
new RenderTargetBitmap(
(int)size.Width,
(int)size.Height,
96d,
96d,
PixelFormats.Pbgra32);
renderBitmap.Render(canvas);
return renderBitmap;
}
/// <summary>
/// Exports the specified plot model to an xps file.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="fileName">The file name.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="background">The background color.</param>
public static void Export(IPlotModel model, string fileName, double width, double height, OxyColor background)
{
using (var xpsPackage = Package.Open(fileName, FileMode.Create, FileAccess.ReadWrite))
{
using (var doc = new XpsDocument(xpsPackage))
{
var canvas = new Canvas { Width = width, Height = height, Background = background.ToBrush() };
canvas.Measure(new Size(width, height));
canvas.Arrange(new Rect(0, 0, width, height));
var rc = new ShapesRenderContext(canvas);
#if !NET35
rc.TextFormattingMode = TextFormattingMode.Ideal;
#endif
model.Update(true);
model.Render(rc, width, height);
canvas.UpdateLayout();
var xpsdw = XpsDocument.CreateXpsDocumentWriter(doc);
xpsdw.Write(canvas);
}
}
}
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;
}
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! ;}";
}
public static bool[,] Rasterize(Point[] points, int width, int height)
{
Contract.Requires(points != null);
Contract.Requires(width > 0);
Contract.Requires(height > 0);
Contract.Requires(width % 8 == 0);
Contract.Ensures(Contract.Result<bool[,]>() != null);
Contract.Ensures(Contract.Result<bool[,]>().GetLength(0) == width);
Contract.Ensures(Contract.Result<bool[,]>().GetLength(1) == height);
var canvas = new Canvas { Background = Brushes.White, Width = width, Height = height };
var polygon = new Polygon { Stroke = Brushes.Black, Fill = Brushes.Black, StrokeThickness = 1, Points = new PointCollection(points) };
canvas.Children.Add(polygon);
RenderOptions.SetEdgeMode(canvas, EdgeMode.Aliased);
canvas.Measure(new Size(width, height));
canvas.Arrange(new Rect(0, 0, canvas.DesiredSize.Width, canvas.DesiredSize.Height));
var rtb = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Default);
rtb.Render(canvas);
var fmb = new FormatConvertedBitmap(rtb, PixelFormats.BlackWhite, null, 0);
var pixels = new byte[width * height / 8];
fmb.CopyPixels(pixels, width / 8, 0);
System.Collections.BitArray ba = new System.Collections.BitArray(pixels);
var result = new bool[width, height];
for (int i = 0, y = 0; y < height; ++y)
for (int x = 0; x < width; ++x, ++i)
result[x, y] = !ba[i];
return result;
}
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 static void Store(IEnumerable<Point> points, int width, int height, string fileName)
{
var canvas = new Canvas { Background = Brushes.White };
canvas.Width = width;
canvas.Height = height;
canvas.Children.Add(new Polyline { Stroke = Brushes.Black, StrokeThickness = 1, Points = new PointCollection(points) });
canvas.Measure(new Size(width, height));
canvas.Arrange(new Rect(0, 0, canvas.DesiredSize.Width, canvas.DesiredSize.Height));
RenderOptions.SetEdgeMode(canvas, EdgeMode.Aliased);
Store(canvas, fileName);
}
protected void CreateIcon(Floor floor)
{
ItemsControl control = new ItemsControl();
Canvas canvas = new Canvas();
control.ItemTemplate = Application.Current.FindResource("SegmentRowTemplate") as DataTemplate;
canvas.Children.Add(control);
control.ItemsSource = floor.Segments;
control.UpdateLayout();
canvas.Measure(new Size(1000, 1000));
canvas.Arrange(new Rect(new Size(1000, 1000)));
RenderTargetBitmap bmp = new RenderTargetBitmap((int)control.DesiredSize.Width, (int)control.DesiredSize.Height, 96, 96, PixelFormats.Pbgra32);
bmp.Render(control);
floor.Icon = bmp;
}
public void SaveFile(Canvas canvas, string filename)
{
RenderTargetBitmap renderBitmap = new RenderTargetBitmap((int)canvas.Width, (int)canvas.Height, 96d, 96d, PixelFormats.Pbgra32);
// needed otherwise the image output is black
canvas.Measure(new Size((int)canvas.Width, (int)canvas.Height));
canvas.Arrange(new Rect(new Size((int)canvas.Width, (int)canvas.Height)));
renderBitmap.Render(canvas);
//JpegBitmapEncoder encoder = new JpegBitmapEncoder();
PngBitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
using (FileStream file = File.Create(filename))
{
encoder.Save(file);
}
}
/// <summary>
/// Renders a UI control into an image.
/// </summary>
/// <param name="control"></param>
/// <param name="isWideTile"></param>
/// <returns></returns>
public static void CreateImage(UIElement control, string imagePath, int width, int height, SolidColorBrush tileBackgroundColor)
{
// 1. Setup dimensions for wide tile.
var bmp = new WriteableBitmap(width, height);
// 2. Get the name of the background image based on theme
var canvas = new System.Windows.Controls.Canvas();
canvas.Width = width;
canvas.Height = height;
canvas.Background = tileBackgroundColor;
canvas.Children.Add(control);
canvas.Measure(new Size(width, height));
canvas.Arrange(new Rect(0, 0, width, height));
canvas.UpdateLayout();
// 4. Now output the control as text.
bmp.Render(canvas, null);
bmp.Invalidate();
// 8. Now save the image to local folder.
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
// FileMode.Open, FileAccess.Read, FileShare.Read,
using (var st = new IsolatedStorageFileStream(imagePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite, store))
{
bmp.SaveJpeg(st, width, height, 0, 100);
st.Close();
}
}
try
{
bmp = null;
canvas.Children.Clear();
GC.Collect();
GC.WaitForPendingFinalizers();
}
catch (Exception ex)
{
Slate.Core.Logging.Logger.Error("Create image", "Warning, attempt to clear up memory for tile image failed", ex);
}
}
/// <summary>
/// Exports the specified plot model to a stream.
/// </summary>
/// <param name="model">The plot model.</param>
/// <param name="stream">The stream to write to.</param>
/// <param name="width">The width of the export image.</param>
/// <param name="height">The height of the exported image.</param>
/// <param name="background">The background.</param>
public static void Export(IPlotModel model, Stream stream, double width, double height, OxyColor background)
{
var canvas = new Canvas { Width = width, Height = height };
if (background.IsVisible())
{
canvas.Background = background.ToBrush();
}
canvas.Measure(new Size(width, height));
canvas.Arrange(new Rect(0, 0, width, height));
var rc = new SilverlightRenderContext(canvas);
model.Update(true);
model.Render(rc, width, height);
canvas.UpdateLayout();
var image = canvas.ToImage();
image.WriteToStream(stream);
}
public static RenderTargetBitmap ToBitmap(this System.Windows.Controls.Canvas canvas)
{
Size size = new Size(canvas.ActualWidth, canvas.ActualHeight);
canvas.Measure(size);
canvas.Arrange(new Rect(size));
// Create a render bitmap and push the surface to it
RenderTargetBitmap renderBitmap =
new RenderTargetBitmap(
(int)size.Width,
(int)size.Height,
96d,
96d,
PixelFormats.Pbgra32);
renderBitmap.Render(canvas);
return(renderBitmap);
}
public BitmapImage canvastoBitmap(Canvas canvas)
{
Size size = new Size(canvas.ActualWidth, canvas.ActualHeight);
canvas.Measure(size);
canvas.Arrange(new Rect(size));
RenderTargetBitmap bitmap = new RenderTargetBitmap((int)canvas.ActualWidth, (int)canvas.ActualHeight, 96d, 96d, PixelFormats.Pbgra32);
bitmap.Render(canvas);
BitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmap));
BitmapImage bmp = new BitmapImage() { CacheOption = BitmapCacheOption.OnLoad };
MemoryStream outStream = new MemoryStream();
encoder.Save(outStream);
outStream.Seek(0, SeekOrigin.Begin);
bmp.BeginInit();
bmp.StreamSource = outStream;
bmp.EndInit();
return bmp;
}
public void ExportToPng(Uri path, Canvas surface)
{
if (path == null)
return;
// Save current canvas transform
Transform transform = surface.LayoutTransform;
// reset current transform (in case it is scaled or rotated)
surface.LayoutTransform = null;
// Get the size of canvas
System.Windows.Size size = new System.Windows.Size(surface.Width, surface.Height);
// Measure and arrange the surface
// VERY IMPORTANT
surface.Measure(size);
surface.Arrange(new Rect(size));
// Create a render bitmap and push the surface to it
RenderTargetBitmap renderBitmap =
new RenderTargetBitmap(
(int)size.Width,
(int)size.Height,
96d,
96d,
PixelFormats.Pbgra32);
renderBitmap.Render(surface);
// Create a file stream for saving image
using (FileStream outStream = new FileStream(path.LocalPath, FileMode.Create))
{
// Use png encoder for our data
PngBitmapEncoder encoder = new PngBitmapEncoder();
// push the rendered bitmap to it
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
// save the data to the stream
encoder.Save(outStream);
}
// Restore previously saved layout
surface.LayoutTransform = transform;
}
public void CanvasLayoutTest()
{
Canvas panel = new Canvas();
FrameworkElement child1 = new FrameworkElement { Width = 200, Height = 100 };
FrameworkElement child2 = new FrameworkElement { Width = 200, Height = 100 };
FrameworkElement child3 = new FrameworkElement { Width = 200, Height = 100 };
FrameworkElement child4 = new FrameworkElement { Width = 200, Height = 100 };
Canvas.SetLeft(child1, 20);
Canvas.SetTop(child1, 10);
Canvas.SetRight(child2, 20);
Canvas.SetTop(child2, 10);
Canvas.SetRight(child3, 20);
Canvas.SetBottom(child3, 10);
Canvas.SetLeft(child4, 20);
Canvas.SetBottom(child4, 10);
panel.Children.Add(child1);
panel.Children.Add(child2);
panel.Children.Add(child3);
panel.Children.Add(child4);
panel.Measure(new Size(1000, 1000));
Assert.AreEqual(Size.Zero, panel.DesiredSize);
panel.Arrange(new Rect(1000, 1000));
Assert.AreEqual(new Size(1000, 1000), panel.VisualSize);
Assert.AreEqual(new Size(200, 100), child1.VisualSize);
Assert.AreEqual(new Size(200, 100), child2.VisualSize);
Assert.AreEqual(new Size(200, 100), child3.VisualSize);
Assert.AreEqual(new Size(200, 100), child4.VisualSize);
Assert.AreEqual(new Point(20, 10), child1.VisualOffset);
Assert.AreEqual(new Point(780, 10), child2.VisualOffset);
Assert.AreEqual(new Point(780, 890), child3.VisualOffset);
Assert.AreEqual(new Point(20, 890), child4.VisualOffset);
}
/// <summary>
/// Преобразует Xaml-canvas в png изображение
/// </summary>
/// <param name="surface">XAML Canvas</param>
/// <returns>Bitmap, rendered from XAML</returns>
public static Bitmap XamlCanvasToPngBitmap(Canvas surface) {
if (surface == null) {
throw new ArgumentNullException("surface");
}
// Save current canvas transform
var transform = surface.LayoutTransform;
// reset current transform (in case it is scaled or rotated)
surface.LayoutTransform = null;
// Get the size of canvas
var size = new System.Windows.Size(surface.Width, surface.Height);
// Measure and arrange the surface
// VERY IMPORTANT
surface.Measure(size);
surface.Arrange(new Rect(size));
// Create a render bitmap and push the surface to it
var renderBitmap =
new RenderTargetBitmap(
(int)size.Width,
(int)size.Height,
96d,
96d,
PixelFormats.Pbgra32);
renderBitmap.Render(surface);
Bitmap bmp;
// Create a file stream for saving image
using (var stream = new MemoryStream()) {
// Use png encoder for our data
var encoder = new PngBitmapEncoder();
// push the rendered bitmap to it
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
// save the data to the stream
encoder.Save(stream);
bmp = new Bitmap(stream);
}
return bmp;
}
/// <summary>
/// Exports the specified plot model to a xml writer.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="writer">The xml writer.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="background">The background.</param>
private static void Export(IPlotModel model, XmlWriter writer, double width, double height, OxyColor background)
{
var c = new Canvas();
if (background.IsVisible())
{
c.Background = background.ToBrush();
}
c.Measure(new Size(width, height));
c.Arrange(new Rect(0, 0, width, height));
var rc = new CanvasRenderContext(c) { UseStreamGeometry = false };
rc.TextFormattingMode = TextFormattingMode.Ideal;
model.Update(true);
model.Render(rc, width, height);
c.UpdateLayout();
XamlWriter.Save(c, writer);
}
public void AttachedTest ()
{
Canvas c = new Canvas ();
Border b = new Border ();
b.Width = 10;
b.Height = 33;
b.Background = new SolidColorBrush (Colors.Orange);
Canvas.SetTop (b, 88);
Canvas.SetLeft (b, 150);
c.Children.Add (b);
c.Measure (new Size (Double.PositiveInfinity, Double.PositiveInfinity));
Assert.AreEqual (new Size (0,0), b.DesiredSize, "b desired");
c.Arrange (new Rect (0,0,400,400));
Assert.AreEqual (new Rect (0,0,0,0), LayoutInformation.GetLayoutSlot (b));
}
public void ComputeActualWidth ()
{
Canvas c = new Canvas ();
Assert.AreEqual (new Size (0,0), c.DesiredSize, "c desired");
Assert.AreEqual (new Size (0,0), new Size (c.ActualWidth,c.ActualHeight), "c actual1");
c.MaxWidth = 25;
c.Width = 50;
c.MinHeight = 33;
Assert.AreEqual (new Size (0,0), c.DesiredSize, "c desired");
Assert.AreEqual (new Size (25,33), new Size (c.ActualWidth,c.ActualHeight), "c actual1");
Assert.AreEqual (new Rect (0,0,0,0), LayoutInformation.GetLayoutSlot (c), "c slot");
c.Measure (new Size (100, 100));
Assert.AreEqual (new Size (0,0), c.DesiredSize, "c desired");
Assert.AreEqual (new Size (25,33), new Size (c.ActualWidth,c.ActualHeight), "c actual2");
Assert.AreEqual (new Size (0,0), c.RenderSize, "c render");
c.Arrange (new Rect (0,0,c.DesiredSize.Width,c.DesiredSize.Height));
Assert.AreEqual (new Size (0,0), c.DesiredSize, "c desired");
Assert.AreEqual (new Size (25,33), new Size (c.ActualWidth,c.ActualHeight), "c actual3");
Assert.AreEqual (new Size (0,0), c.RenderSize, "c render");
}
private static VisualBrush CreateHatchBrush(Styles.Brush brush, int viewbox, int viewport, IEnumerable<Geometry> geometries)
{
var elements = new List<UIElement>();
if (brush.Background != null)
elements.Add(CreateBackground(brush.Background, viewbox));
var stroke = new SolidColorBrush(GetColor(brush.Color));
var canvas = new Canvas();
foreach (var geometry in geometries)
{
canvas.Children.Add(new Path
{
Stroke = stroke,
Data = geometry,
StrokeThickness = 1,
SnapsToDevicePixels = false
});
}
canvas.Arrange(new Rect(0, 0, viewbox, viewbox));
elements.Add(canvas);
return CreatePatternVisual(elements, viewport, viewbox);
}
private static VisualBrush CreatePatternVisual(IEnumerable<UIElement> elements, int viewPort, int viewbox)
{
var canvas = new Canvas();
foreach (var vis in elements)
{
canvas.Children.Add(vis);
}
var visualBrush = new VisualBrush
{
TileMode = TileMode.Tile,
Viewport = new Rect(0, 0, viewPort, viewPort),
ViewportUnits = BrushMappingMode.Absolute,
Viewbox = new Rect(0, 0, viewbox, viewbox),
ViewboxUnits = BrushMappingMode.Absolute,
Visual = canvas,
};
canvas.Arrange(new Rect(0, 0, viewbox, viewbox));
return visualBrush;
}
public static string XamlCanvasToPngBase64(Canvas surface, double width, double height) {
if (surface == null) {
throw new ArgumentNullException("surface");
}
//Grid newSurface = new Grid();
//foreach (UIElement child in surface.Children) {
// var xaml = System.Windows.Markup.XamlWriter.Save(child);
// var deepCopy = System.Windows.Markup.XamlReader.Parse(xaml) as UIElement;
// newSurface.Children.Add(deepCopy);
//}
// Get the size of canvas
var size = new Size(width, height);
// Measure and arrange the surface
// VERY IMPORTANT
surface.Measure(size);
surface.Arrange(new Rect(size));
double maxWidth = width;
double maxheight = height;
foreach (UIElement child in surface.Children)
{
if (child.RenderSize.Height > maxheight)
{
maxheight = child.RenderSize.Height;
}
if (child.RenderSize.Width > maxWidth)
{
maxWidth = child.RenderSize.Width;
}
}
// Create a render bitmap and push the surface to it
var renderBitmap =
new RenderTargetBitmap(
(int)maxWidth,
(int)maxheight,
96d,
96d,
PixelFormats.Pbgra32);
renderBitmap.Render(surface);
// Create a file stream for saving image
using (var stream = new MemoryStream()) {
// Use png encoder for our data
var encoder = new PngBitmapEncoder();
// push the rendered bitmap to it
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
// save the data to the stream
encoder.Save(stream);
byte[] imageBytes = stream.ToArray();
return Convert.ToBase64String(imageBytes);
}
}
/// <summary>
/// Exports the specified plot model to a bitmap.
/// </summary>
/// <param name="model">The model to export.</param>
/// <returns>A bitmap.</returns>
public BitmapSource ExportToBitmap(IPlotModel model)
{
var scale = 96d / this.Resolution;
var canvas = new Canvas { Width = this.Width * scale, Height = this.Height * scale, Background = this.Background.ToBrush() };
canvas.Measure(new Size(canvas.Width, canvas.Height));
canvas.Arrange(new Rect(0, 0, canvas.Width, canvas.Height));
var rc = new CanvasRenderContext(canvas) { RendersToScreen = false };
rc.TextFormattingMode = TextFormattingMode.Ideal;
model.Update(true);
model.Render(rc, canvas.Width, canvas.Height);
canvas.UpdateLayout();
var bmp = new RenderTargetBitmap(this.Width, this.Height, this.Resolution, this.Resolution, PixelFormats.Pbgra32);
bmp.Render(canvas);
return bmp;
// alternative implementation:
// http://msdn.microsoft.com/en-us/library/system.windows.media.imaging.rendertargetbitmap.aspx
// var dv = new DrawingVisual();
// using (var ctx = dv.RenderOpen())
// {
// var vb = new VisualBrush(canvas);
// ctx.DrawRectangle(vb, null, new Rect(new Point(), new Size(width, height)));
// }
// bmp.Render(dv);
}
//convert canvas object to image
public void Convert_to_Image(Canvas can, int pane_number)
{
if (pane_number == -1)
{
//clear hashtable as new plot will overwirte previous image
Canvas_Obj.Clear();
Updates.Clear();
PngBitmapEncoder encoder = new PngBitmapEncoder();
Canvas_Obj[1] = can;
Transform transform = can.LayoutTransform;
// reset current transform incase of scalling or rotating
can.LayoutTransform = null;
// get size of canvas
Size size = new Size(can.Width, can.Height);
// measure and arrange the canvas
can.Measure(size);
can.Arrange(new Rect(size));
// create and render surface and push bitmap to it
RenderTargetBitmap renderBitmap = new RenderTargetBitmap((Int32)size.Width, (Int32)size.Height, 100d, 100d, PixelFormats.Pbgra32);
// now render surface to bitmap
renderBitmap.Render(can);
// puch rendered bitmap into it
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
//passing encoder to plotreceiver module
returnEncoderImage(encoder);
// create image to return
Image returnImage = new Image();
// set source of image as frame
returnImage.Source = encoder.Frames[0];
// restore previously saved layout
can.LayoutTransform = transform;
//check if the directory exists or not and if not exist create a new one.
if (!Directory.Exists(imagepath))
Directory.CreateDirectory(imagepath);
// string for saving
String tempPath = imagepath + "\\image.png";
// create a file stream for saving image
using (FileStream outStream = new FileStream(tempPath, FileMode.Create))
{
encoder.Save(outStream);
}
}
else
{
PngBitmapEncoder encoder = new PngBitmapEncoder();
int resized_pane_number = 0;
Canvas resized_canvas = new Canvas();
//IDictionaryEnumerator entry = Canvas_Obj.GetEnumerator();
foreach (DictionaryEntry entry in Canvas_Obj)
{
Canvas canvas_value = (Canvas)entry.Value;
if (canvas_value.Height != can.Height)
{
resized_canvas = resize_canvas(canvas_value, pane_number);
resized_pane_number = FindKey(canvas_value);
Updates.Add(resized_pane_number, resized_canvas);
}
}
foreach (DictionaryEntry upd in Updates)
{
Canvas_Obj[upd.Key] = upd.Value;
}
Canvas_Obj[pane_number] = can;
Canvas cannew = new Canvas();
cannew = mergePlots();
Transform transform = can.LayoutTransform;
// reset current transform incase of scalling or rotating
can.LayoutTransform = null;
// get size of canvas
Size size = new Size(cannew.Width,cannew.Height);
// measure and arrange the canvas
cannew.Measure(size);
cannew.Arrange(new Rect(size));
// create and render surface and push bitmap to it
RenderTargetBitmap renderBitmap = new RenderTargetBitmap((Int32)size.Width, (Int32)size.Height, 100d, 100d, PixelFormats.Pbgra32);
// now render surface to bitmap
renderBitmap.Render(cannew);
// puch rendered bitmap into it
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
//passing encoder to plotreceiver module
returnEncoderImage(encoder);
// create image to return
Image returnImage = new Image();
// set source of image as frame
returnImage.Source = encoder.Frames[0];
// restore previously saved layout
can.LayoutTransform = transform;
//check if the directory exists or not and if not exist create a new one.
if (!Directory.Exists(imagepath))
Directory.CreateDirectory(imagepath);
// string for saving
String tempPath = imagepath + "\\image.png";
// create a file stream for saving image
using (FileStream outStream = new FileStream(tempPath, FileMode.Create))
{
encoder.Save(outStream);
}
}
}
private static void Render(Canvas target, IViewport viewport, IEnumerable<ILayer> layers,
Color background, bool rasterizing)
{
target.BeginInit();
target.Background = background == null ? null : new XamlMedia.SolidColorBrush {Color = background.ToXaml()};
target.Visibility = Visibility.Collapsed;
foreach (var child in target.Children)
{
(child as Canvas)?.Children.Clear();
}
target.Children.Clear();
layers = layers.ToList();
foreach (var layer in layers)
{
if (!layer.Enabled) continue;
if (layer.MinVisible > viewport.Resolution) continue;
if (layer.MaxVisible < viewport.Resolution) continue;
RenderLayer(target, viewport, layer, rasterizing);
}
target.Arrange(new Rect(0, 0, viewport.Width, viewport.Height));
target.Visibility = Visibility.Visible;
if (DeveloperTools.DeveloperMode)
{
DrawDebugInfo(target, layers);
}
target.EndInit();
}
// ------------------------- CreateThirdVisual ------------------------
/// <summary>
/// Creates content for the third visual sample.</summary>
/// <param name="shouldMeasure">
/// true to remeasure the layout.</param>
/// <returns>
/// The canvas containing the visual.</returns>
public Canvas CreateThirdVisual(bool shouldMeasure)
{
Canvas canvas = new Canvas();
RadialGradientBrush brush = new RadialGradientBrush();
brush.GradientStops.Add(new GradientStop(Colors.Black, 0));
brush.GradientStops.Add(new GradientStop(Colors.Yellow, 0.5));
brush.GradientStops.Add(new GradientStop(Colors.Red, 1));
brush.SpreadMethod = GradientSpreadMethod.Repeat;
brush.Center = new Point(0.5, 0.5);
brush.RadiusX = 0.2;
brush.RadiusY = 0.2;
brush.GradientOrigin = new Point(0.5, 0.5);
Rectangle r = new Rectangle();
r.Fill = brush;
Thickness thick = new Thickness();
thick.Left = 100;
thick.Top = 100;
r.Margin = thick;
r.Width = 400;
r.Height = 400;
canvas.Children.Add(r);
LinearGradientBrush linear = new LinearGradientBrush();
linear.GradientStops.Add(new GradientStop(Colors.Blue, 0));
linear.GradientStops.Add(new GradientStop(Colors.Yellow, 1));
linear.SpreadMethod = GradientSpreadMethod.Reflect;
linear.StartPoint = new Point(0, 0);
linear.EndPoint = new Point(0.06125, 0);
linear.Opacity = 0.5;
r = new Rectangle();
r.Fill = linear;
thick = new Thickness();
thick.Left = 200;
thick.Top = 200;
r.Margin = thick;
r.Width = 400;
r.Height = 400;
canvas.Children.Add(r);
if (shouldMeasure)
{
Size sz = new Size(8.5 * 96, 11 * 96);
canvas.Measure(sz);
canvas.Arrange(new Rect(new Point(), sz));
canvas.UpdateLayout();
}
return canvas;
}
public void MergeImages(string fl)
{
Canvas canvas = new Canvas();
if (zoom == 3)
{
canvas.Width = 512 * 6.5;
canvas.Height = 512 * 3.25;
}
else if (zoom == 2)
{
canvas.Width = 512 * 3.25;
canvas.Height = 512 * 1.625;
}
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));
StackPanel mainPanel = new StackPanel();
mainPanel.Orientation = Orientation.Vertical;
for (int j = 0; j < limitY; j++)
{
StackPanel ph = new StackPanel();
ph.Orientation = Orientation.Horizontal;
for (int k = 0; k < limitX; k++)
{
Image stackImg = new Image();
stackImg.Source = FromStream(previousJumpBuffStream[j][k]);
ph.Children.Add(stackImg);
}
mainPanel.Children.Add(ph);
}
mainPanel.UpdateLayout();
canvas.Children.Add(mainPanel);
canvas.UpdateLayout();
RenderTargetBitmap _RenderTargetBitmap = new RenderTargetBitmap((int)Width, (int)Height, 96, 96, PixelFormats.Pbgra32);
_RenderTargetBitmap.Render(mainPanel);
ImageSource mergedImages = _RenderTargetBitmap;
SaveImg(mergedImages, fl);
Stream s = File.OpenRead(fl);
buffStream.Add(s);
}
/// <summary>
/// Exports the specified plot model to a bitmap.
/// </summary>
/// <param name="model">The plot model.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="background">The background.</param>
/// <param name="dpi">The resolution.</param>
/// <returns>A bitmap.</returns>
public static BitmapSource ExportToBitmap(PlotModel model, int width, int height, OxyColor background = null, int dpi = 96)
{
var canvas = new Canvas { Width = width, Height = height, Background = background.ToBrush() };
canvas.Measure(new Size(width, height));
canvas.Arrange(new Rect(0, 0, width, height));
var rc = new ShapesRenderContext(canvas) { RendersToScreen = false };
model.Update();
model.Render(rc, width, height);
canvas.UpdateLayout();
var bmp = new RenderTargetBitmap(width, height, dpi, dpi, PixelFormats.Pbgra32);
bmp.Render(canvas);
return bmp;
// alternative implementation:
// http://msdn.microsoft.com/en-us/library/system.windows.media.imaging.rendertargetbitmap.aspx
// var dv = new DrawingVisual();
// using (var ctx = dv.RenderOpen())
// {
// var vb = new VisualBrush(canvas);
// ctx.DrawRectangle(vb, null, new Rect(new Point(), new Size(width, height)));
// }
// bmp.Render(dv);
}
public void CanvasCallsLayoutTest ()
{
var parent = new Canvas ();
LayoutPoker c = new LayoutPoker ();
parent.Children.Add (c);
c.Width = 50;
c.Height = 50;
int measure_called = 0;
int arrange_called = 0;
c.Measured += (Size real) => {
c.MeasureResult = real;
measure_called++;
};
c.Arranged += (Size real) => {
c.ArrangeResult = real;
arrange_called++;
};
parent.Measure (new Size (100, 100));
Assert.AreEqual (0, arrange_called, "arrange called 0");
Assert.AreEqual (1, measure_called, "measure called 0");
Assert.AreEqual (new Size (0,0), c.DesiredSize);
Assert.AreEqual (new Size (0,0), parent.DesiredSize);
parent.Arrange (new Rect (0, 0, 100, 100));
Assert.AreEqual (1, arrange_called, "arrange called 1");
Assert.AreEqual (1, measure_called, "measure called 1");
c.InvalidateMeasure ();
c.InvalidateArrange ();
parent.InvalidateMeasure ();
parent.InvalidateArrange ();
parent.Arrange (new Rect (0, 0, 100, 100));
Assert.AreEqual (2, arrange_called, "arrange called 2");
Assert.AreEqual (2, measure_called, "measure called 2");
}
private void btSaveImage_Click(object sender, RoutedEventArgs e) {
if (_collector == null)
return;
// Create new canvas and renderer
var cnv = new Canvas() { Margin = cnvChart.Margin, Width = cnvChart.ActualWidth, Height = cnvChart.ActualHeight, Background = System.Windows.Media.Brushes.White };
var ch = new ChartRendering.ChartRenderer(cnv, _collector.Datas);
cnv.Measure(new System.Windows.Size(double.PositiveInfinity, double.PositiveInfinity));
cnv.Arrange(new Rect(0, 0, cnv.DesiredSize.Width, cnv.DesiredSize.Height));
var cwidth = (int)cnv.RenderSize.Width;
var cheight = (int)(cnv.RenderSize.Height + cnv.Margin.Top * 2);
var rtb = new RenderTargetBitmap(cwidth, cheight, 96d, 96d, PixelFormats.Default);
// Generate a white background
var dv = new DrawingVisual();
var dvct = dv.RenderOpen();
dvct.DrawRectangle(System.Windows.Media.Brushes.White, null, new Rect(0, 0, rtb.Width, rtb.Height));
dvct.Close();
rtb.Render(dv);
// Render chart and create Bitmap
ch.Render(false);
// Add additional informations overlays
AddChartImageInfos(cnv);
cnv.UpdateLayout();
rtb.Render(cnv);
// Open file dialog and save image if OK
var fd = new SaveFileDialog();
fd.Filter = "PNG Images|*.png";
fd.DefaultExt = ".png";
fd.InitialDirectory = Properties.Settings.Default.fdpath_img;
if (true == fd.ShowDialog(this)) {
Properties.Settings.Default.fdpath_img = Path.GetDirectoryName(fd.FileName);
Properties.Settings.Default.Save();
var bf = BitmapFrame.Create(rtb);
var pngEncoder = new PngBitmapEncoder();
pngEncoder.Frames.Add(bf);
using (var st = System.IO.File.OpenWrite(fd.FileName)) {
pngEncoder.Save(st);
}
var result = MessageBox.Show("Show generated file in Explorer ?", "Image successfully generated", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (result == MessageBoxResult.Yes)
System.Diagnostics.Process.Start("explorer.exe", "/select, " + fd.FileName);
}
}
private void Test_Click(object sender, RoutedEventArgs e)
{
Canvas c = new Canvas();
ItemsControl control = new ItemsControl();
var template = uxDataFloor.ItemTemplate;
control.ItemTemplate = Application.Current.FindResource("SegmentRowTemplate") as DataTemplate;
control.ItemsSource = _viewModel.CurrentBuilding.Floors[0].Segments;
c.Children.Add(control);
c.Measure(new Size(1000, 1000));
c.Arrange(new Rect(new Size(1000, 1000)));
RenderTargetBitmap bmp = new RenderTargetBitmap((int)control.DesiredSize.Width, (int)control.DesiredSize.Height, 96, 96, PixelFormats.Pbgra32);
bmp.Render(control);
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bmp));
using (Stream stm = File.Create(@"D:\test.png"))
{
encoder.Save(stm);
}
return;
//int width = (int)uxDataFloor.ActualWidth;
//int height = (int)uxDataFloor.ActualHeight;
//int width = 1000;
//int height = 1000;
//uxDataFloor.Measure(new Size(width, height));
//uxDataFloor.Arrange(new Rect(uxDataFloor.DesiredSize));
//RenderTargetBitmap bmp = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32);
//bmp.Render(uxDataFloor);
//var encoder = new PngBitmapEncoder();
//encoder.Frames.Add(BitmapFrame.Create(bmp));
//using (Stream stm = File.Create(@"D:\test.png"))
//{
// encoder.Save(stm);
//}
}
/// <summary>
/// Creates image from canvas with map background.
/// </summary>
/// <param name="mapImage">Map image.</param>
/// <param name="canvas">Canvas to draw.</param>
/// <returns>Created image.</returns>
private Image _CreateImage(MapImage mapImage, SysControls.Canvas canvas)
{
Debug.Assert(null != mapImage);
Debug.Assert(null != canvas);
Image imageWithData = null;
RenderTargetBitmap bmp = null;
SysControls.Canvas outer = null;
Image sourceImage = null;
using (MemoryStream sourceStream = new MemoryStream((byte[])mapImage.ImageData))
sourceImage = Image.FromStream(sourceStream);
try
{
var bitmap = sourceImage as Bitmap;
Debug.Assert(null != bitmap);
ImageBrush imageBrush = _CreateImageBrush(bitmap);
outer = new SysControls.Canvas();
outer.Width = mapImage.ImageWidth;
outer.Height = mapImage.ImageHeight;
outer.Children.Add(canvas);
outer.Background = (ImageBrush)imageBrush.GetCurrentValueAsFrozen();
outer.Arrange(new Rect(0, 0, outer.Width, outer.Height));
bmp = new RenderTargetBitmap((int)outer.Width,
(int)outer.Height,
mapImage.ImageDPI,
mapImage.ImageDPI,
PixelFormats.Pbgra32);
bmp.Render(outer);
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bmp));
using (MemoryStream stream = new MemoryStream())
{
encoder.Save(stream);
imageWithData = Image.FromStream(stream);
}
}
finally
{ // Clear and dispose all used stuff
if (outer != null)
{
outer.UpdateLayout();
outer.Children.Clear();
}
canvas.UpdateLayout();
foreach (object child in canvas.Children)
{
var symbolControl = child as SymbolControl;
if (symbolControl != null)
{
symbolControl.Template = null;
}
}
canvas.Children.Clear();
if (bmp != null)
{
bmp.Clear();
}
if (sourceImage != null)
{
sourceImage.Dispose();
}
}
return(imageWithData);
}
